Skip to content

Free open-source image editor for the browser

23.0 KB
Raw Blame
import { expect, spyOn, test } from "bun:test";
import { init, target } from "vgpu/mock";
import { createImageLayer, createLayer, createMask } from "@/app/editor/layers";
import { createEditorRenderer } from "@/app/editor/renderer";
import {
  type BrushStroke,
  completeFields,
  createDocument,
  createResources,
  findLayer,
  removePatches,
  sceneFields,
} from "@/core/document";
import { createImageSource } from "@/core/image";
import { imageFrame } from "@/core/image/frame";
import { createRenderGraph, input } from "@/core/renderer";
import { setAdjustments } from "@/features/adjustments/edits";
import {
  addHealPatch,
  addHealStroke,
  addRemovePatch,
  deleteHealPatch,
  duplicateHealPatch,
  extendHealPatch,
  setHealDestination,
  setHealPatch,
  setHealSource,
} from "@/features/heal/edits";
import { inpaintField } from "@/features/heal/inpaint";
import { addLayer, deleteLayer, setLayer } from "@/features/layers/edits";

function healFixture(size: readonly [number, number] = [64, 64]) {
  const resources = createResources();
  const document = createDocument(
    {
      frame: imageFrame(size),
      layers: [createImageLayer("source", "Photo")],
    },
    resources,
  );
  const layer = addLayer(document, createLayer("heal"));
  return { document, layer };
}

const dab: BrushStroke = {
  mode: "paint",
  size: 8,
  feather: 0,
  flow: 1,
  points: [[10, 10, 1]],
};

test("Remove passes never overwrite distinct uniforms before their frame submits", async () => {
  const gpu = await init();
  const source = target(gpu, { size: [64, 64], format: "rgba16float" });
  const coverage = target(gpu, { size: [64, 64], format: "r8unorm" });
  const graph = createRenderGraph(gpu);
  const uploads = spyOn(gpu.gpu.queue, "writeBuffer");
  const lattice = { origin: [0, 0], scale: 1, size: source.size } as const;
  try {
    graph.render(
      [
        inpaintField(
          input(source),
          { coverage: input(coverage), origin: [0, 0] },
          lattice,
          "remove",
        ),
      ],
      { set: 1, kept: [] },
    );
    const uniforms = new Map<GPUBuffer, Uint8Array>();
    for (const [buffer, , data] of uploads.mock.calls) {
      const bytes = ArrayBuffer.isView(data)
        ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
        : new Uint8Array(data);
      const previous = uniforms.get(buffer);
      if (previous) expect(bytes).toEqual(previous);
      uniforms.set(buffer, bytes.slice());
    }
    expect(uniforms.size).toBeGreaterThan(1);
  } finally {
    uploads.mockRestore();
    graph.dispose();
    coverage.color.dispose();
    source.color.dispose();
    gpu.dispose();
  }
});

test("patch strokes add, erase, replay on undo, and move together while retaining the donor", async () => {
  const gpu = await init();
  const source = createImageSource(
    target(gpu, { size: [1024, 1024], format: "rgba16float" }),
  );
  const { document, layer } = healFixture([1024, 1024]);
  const renderer = createEditorRenderer(gpu, source);
  try {
    const id = addHealPatch(document, layer, dab, [20, 0], "clone");
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().stamped).toBe(1);
    addHealStroke(document, layer, id, { ...dab, points: [[30, 30, 1]] });
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().stamped).toBe(2);
    addHealStroke(document, layer, id, { ...dab, mode: "erase", size: 1000 });
    await renderer.update(document.scene.getState());
    // Erasure outside the patch never grows its raster or repeats earlier dabs.
    expect(renderer.inspect().stamped).toBe(3);
    expect(renderer.inspect().rasters[0].size).toEqual([256, 256]);
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().stamped).toBe(3);
    document.history.undo();
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().stamped).toBe(5);
    document.history.redo();
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().stamped).toBe(6);
    setHealDestination(document, layer, id, [20, 25]);
    expect(patchesOf(document, layer)).toMatchObject([
      {
        id,
        mode: "clone",
        offset: [10, -15],
        strokes: [
          { mode: "paint", points: [[20, 25, 1]] },
          { mode: "paint", points: [[40, 45, 1]] },
          { mode: "erase", points: [[20, 25, 1]] },
        ],
      },
    ]);
  } finally {
    renderer.dispose();
    document.dispose();
    source.dispose();
    gpu.dispose();
  }
});

test("Remove patches edit, move, duplicate, and undo without a donor", () => {
  const { document, layer } = healFixture();
  try {
    document.history.begin();
    const patch = addRemovePatch(document, layer, { ...dab, feather: 0.3 });
    extendHealPatch(document, layer, [[12, 14, 1]]);
    document.history.commit();
    setHealPatch(document, layer, patch, { opacity: 0.5 });
    setHealDestination(document, layer, patch, [20, 30]);
    const copy = duplicateHealPatch(document, layer, patch);
    expect(patchesOf(document, layer)).toMatchObject([
      {
        id: patch,
        mode: "remove",
        opacity: 0.5,
        feather: 0.3,
        strokes: [
          {
            points: [
              [20, 30, 1],
              [22, 34, 1],
            ],
          },
        ],
      },
      { id: copy, mode: "remove" },
    ]);
    expect(patchesOf(document, layer)[0]).not.toHaveProperty("offset");
    expect(() => setHealSource(document, layer, patch, [10, 10])).toThrow(
      "no donor",
    );
    document.history.undo();
    expect(patchesOf(document, layer)).toHaveLength(1);
    document.history.undo();
    document.history.undo();
    document.history.undo();
    expect(patchesOf(document, layer)).toHaveLength(0);
    document.history.redo();
    expect(patchesOf(document, layer)[0].mode).toBe("remove");
  } finally {
    document.dispose();
  }
});

function patchesOf(document: ReturnType<typeof createDocument>, layer: string) {
  const healing = findLayer(document.scene.getState().layers, layer);
  if (healing?.kind !== "heal") throw Error("Healing layer missing.");
  return healing.patches;
}

test("a nested Remove synthesizes once for its strokes, whatever changes below or hides it, synthesizes its whole shape again on new strokes, and undoes without solving again", async () => {
  const gpu = await init();
  const source = createImageSource(
    target(gpu, { size: [128, 96], format: "rgba16float" }),
  );
  const { document } = healFixture([128, 96]);
  const renderer = createEditorRenderer(gpu, source, {
    field: (id) => document.resources.field(id),
    saveField: (id, field) => document.resources.fillField(id, field),
  });
  const mask = addLayer(
    document,
    createMask({ kind: "linear", start: [0, 0], end: [0, 96] }),
  );
  const layer = addLayer(document, createLayer("heal"), { inside: mask });
  const patch = addRemovePatch(document, layer, {
    ...dab,
    points: [[64, 48, 1]],
  });
  const render = (interactive = false, density = 1) =>
    renderer.update(
      document.scene.getState(),
      undefined,
      interactive,
      undefined,
      density,
    );
  const solves = () =>
    renderer.inspect().passes.some((name) => name.includes("/inpaint/"));
  const fields = () =>
    renderer.inspect().rasters.filter(({ id }) => id.endsWith("/field"));
  const own = () => {
    const healing = findLayer(document.scene.getState().layers, layer);
    const found = healing?.kind === "heal" ? healing.patches[0] : undefined;
    if (found?.mode !== "remove") throw Error("The Remove patch is gone.");
    return found.field;
  };
  /** Whether the document saved the field the renderer synthesized, once its readback finishes. */
  const saved = async () => {
    await renderer.captureFields([]);
    return document.resources.field(own()) !== undefined;
  };
  try {
    await render();
    expect(solves()).toBe(true);
    expect(fields()).toMatchObject([{ id: `${own()}/field` }]);
    expect(await saved()).toBe(true);
    setHealPatch(document, layer, patch, { opacity: 0.5, feather: 0.4 });
    await render();
    expect(solves()).toBe(false);
    for (const id of [layer, mask]) {
      for (const change of [{ visible: false }, { opacity: 0 }]) {
        setLayer(document, id, change);
        await render();
        expect(fields()).toHaveLength(1);
        setLayer(document, id, { visible: true, opacity: 1 });
        await render();
        expect(solves()).toBe(false);
      }
    }
    setLayer(document, mask, { opacity: 0.5 });
    setAdjustments(document, { exposure: 1 }, mask);
    await render();
    expect(solves()).toBe(false);
    await render(true, 0.5);
    expect(solves()).toBe(false);
    for (const mode of ["paint", "erase"] as const) {
      const before = own();
      addHealStroke(document, layer, patch, {
        ...dab,
        mode,
        size: 2,
        points: [[64, 48, 1]],
      });
      // A new stroke takes a new field, to synthesize for the whole new shape.
      expect(own()).not.toBe(before);
      expect(document.resources.field(own())).toBeUndefined();
      // A gesture's proxy shows the new stroke unfilled; its end synthesizes it in full.
      await render(true, 0.5);
      expect(solves()).toBe(false);
      await render();
      expect(solves()).toBe(true);
      expect(await saved()).toBe(true);
      setHealPatch(document, layer, patch, {
        opacity: mode === "paint" ? 0.6 : 0.5,
      });
      await render();
      expect(solves()).toBe(false);
    }
    // Undo and redo reach every stroke version's saved field, and show it without solving again.
    for (const travel of ["undo", "redo"] as const) {
      for (let step = 0; step < 4; step++) {
        document.history[travel]();
        await render();
        expect(solves()).toBe(false);
      }
    }
    setHealDestination(document, layer, patch, [40, 40]);
    await render();
    expect(solves()).toBe(true);
    deleteLayer(document, mask);
    await render();
    expect(fields()).toEqual([]);
  } finally {
    renderer.dispose();
    document.dispose();
    source.dispose();
    gpu.dispose();
  }
});

test("renders follow the display's density, except that a proxy lacking a Remove patch's field renders in full once", async () => {
  const gpu = await init();
  const source = createImageSource(
    target(gpu, { size: [128, 96], format: "rgba16float" }),
  );
  const { document } = healFixture([128, 96]);
  const renderer = createEditorRenderer(gpu, source, {
    field: (id) => document.resources.field(id),
  });
  const render = (interactive = false, density = 0.5) =>
    renderer.update(
      document.scene.getState(),
      undefined,
      interactive,
      undefined,
      density,
    );
  const size = () => renderer.outputImage().size;
  const fields = () =>
    renderer.inspect().rasters.filter(({ id }) => id.endsWith("/field"));
  try {
    await render();
    expect(size()).toEqual([64, 48]);
    const layer = addLayer(document, createLayer("heal"));
    addRemovePatch(document, layer, { ...dab, points: [[64, 48, 1]] });
    // A gesture shows the patch unfilled; its end synthesizes the field in full apart, and shows the proxy.
    await render(true);
    expect(size()).toEqual([64, 48]);
    expect(fields()).toHaveLength(0);
    await render();
    expect(size()).toEqual([64, 48]);
    expect(fields()).toHaveLength(1);
    expect(renderer.inspect().passes).toContain(
      `layer/${layer}/${patchesOf(document, layer)[0].id}/blend`,
    );
    // The full-size textures the synthesis used go with the proxy's render; the proxy's stay.
    expect(renderer.inspect().textures.every(({ size }) => size[0] <= 64)).toBe(
      true,
    );
    setAdjustments(document, { exposure: 1 });
    await render();
    expect(size()).toEqual([64, 48]);
    // A finer display renders in full; returning to a reduction already rendered allocates nothing,
    // since its proxy and intermediates stayed.
    await render(false, 1);
    expect(size()).toEqual([128, 96]);
    const made = spyOn(gpu.gpu, "createTexture");
    await render(false, 0.5);
    expect(size()).toEqual([64, 48]);
    expect(made).not.toHaveBeenCalled();
  } finally {
    renderer.dispose();
    document.dispose();
    gpu.dispose();
  }
});

test("a snapshot taken while a Remove field is read back keeps it once its photo closes", async () => {
  const gpu = await init();
  const source = createImageSource(
    target(gpu, { size: [128, 96], format: "rgba16float" }),
  );
  const { document, layer } = healFixture([128, 96]);
  const renderer = createEditorRenderer(gpu, source, {
    field: (id) => document.resources.field(id),
    saveField: (id, field) => document.resources.fillField(id, field),
  });
  document.onCaptureFields((ids) => renderer.captureFields(ids));
  try {
    addRemovePatch(document, layer, { ...dab, points: [[64, 48, 1]] });
    const [{ patch }] = removePatches(document.scene.getState().layers);
    // The render synthesizes the field and starts reading it back; another photo then closes this one.
    void renderer.update(document.scene.getState());
    const snapshot = completeFields(document, sceneFields(document));
    renderer.dispose();
    document.dispose();
    expect((await snapshot).get(patch.field)).toBeDefined();
  } finally {
    source.dispose();
    gpu.dispose();
  }
});

test("a snapshot reads back a Remove field whose save failed, and fails when that fails too", async () => {
  const gpu = await init();
  const source = createImageSource(
    target(gpu, { size: [128, 96], format: "rgba16float" }),
  );
  const { document, layer } = healFixture([128, 96]);
  // A save that fails while `failing` holds, as a readback the device refuses would.
  let failing = true;
  const renderer = createEditorRenderer(gpu, source, {
    field: (id) => document.resources.field(id),
    saveField: (id, field) => {
      if (failing) throw Error("Device lost");
      document.resources.fillField(id, field);
    },
  });
  const stop = document.onCaptureFields((ids) => renderer.captureFields(ids));
  try {
    addRemovePatch(document, layer, { ...dab, points: [[64, 48, 1]] });
    const [{ patch }] = removePatches(document.scene.getState().layers);
    await renderer.update(document.scene.getState());
    await renderer.captureFields([]);
    expect(document.resources.field(patch.field)).toBeUndefined();
    const records = sceneFields(document);
    await expect(completeFields(document, records)).rejects.toThrow(
      "Device lost",
    );
    failing = false;
    const completed = await completeFields(document, records);
    expect(completed.get(patch.field)).toBeDefined();
    expect(document.resources.field(patch.field)).toBeDefined();
  } finally {
    stop();
    renderer.dispose();
    document.dispose();
    source.dispose();
    gpu.dispose();
  }
});

test("heal patches reuse brush rasters, scale with the proxy, undo, and release with the layer", async () => {
  const gpu = await init();
  const source = createImageSource(
    target(gpu, { size: [256, 192], format: "rgba16float" }),
  );
  const resources = createResources();
  const sourceId = resources.add(new File([], "photo.png"), source);
  const document = createDocument(
    {
      frame: imageFrame(source.image.size),
      layers: [createImageLayer(sourceId, "Photo")],
    },
    resources,
  );
  const renderer = createEditorRenderer(gpu, source);
  try {
    const id = addLayer(document, createLayer("heal"));
    const stroke: BrushStroke = {
      mode: "paint",
      size: 30,
      feather: 0.4,
      flow: 1,
      points: [[100, 80, 1]],
    };
    document.history.begin();
    const patch = addHealPatch(document, id, stroke, [60, 0]);
    const created = document.scene
      .getState()
      .layers.find((item) => item.id === id);
    expect(
      created?.kind === "heal" &&
        created.patches.find((item) => item.id === patch),
    ).toMatchObject({ feather: 0.4, strokes: [{ size: 30, feather: 0 }] });
    await renderer.update(document.scene.getState(), id, true, undefined, 0.25);
    expect(renderer.fullImage().size).toEqual([64, 48]);
    expect(renderer.inspect().rasters).toEqual([
      { id: `layer/${id}/${patch}`, size: [256, 192], format: "r8unorm" },
    ]);
    const stamped = renderer.inspect().stamped;
    extendHealPatch(document, id, [[120, 80, 1]]);
    await renderer.update(document.scene.getState(), id, true, undefined, 0.25);
    expect(renderer.inspect().stamped).toBeGreaterThan(stamped);
    const extended = renderer.inspect().stamped;
    document.history.commit();
    // The view shows every source pixel again, so the render returns to full size.
    await renderer.update(document.scene.getState());
    expect(renderer.fullImage().size).toEqual([256, 192]);
    expect(renderer.inspect().stamped).toBe(extended);
    expect(renderer.inspect().passes.at(-1)).toBe(`layer/${id}/${patch}/blend`);
    expect(renderer.inspect().passes.length).toBeGreaterThan(1);
    expect(renderer.inspect().effects).toBeLessThan(15);
    const textures = renderer.inspect().textures;
    setHealSource(document, id, patch, [70, 0]);
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().textures).toEqual(textures);
    expect(renderer.inspect().stamped).toBe(extended);
    document.history.undo();
    document.history.undo();
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().rasters).toEqual([]);
    expect(renderer.inspect().passes).toEqual([]);
    document.history.redo();
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().rasters).toHaveLength(1);
    expect(() =>
      addHealPatch(document, id, { ...stroke, mode: "erase" }, [1, 2]),
    ).toThrow("painted");
    expect(() => setHealSource(document, id, patch, [NaN, 0])).toThrow(
      "Invalid heal source",
    );
    expect(() => setHealPatch(document, id, patch, { feather: NaN })).toThrow(
      "feather",
    );
    setHealSource(document, id, patch, [0, 0]);
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().effects).toBe(0);
    expect(renderer.inspect().rasters).toEqual([]);
    deleteLayer(document, id);
    await renderer.update(document.scene.getState());
    expect(renderer.inspect().rasters).toEqual([]);
  } finally {
    renderer.dispose();
    document.dispose();
    gpu.dispose();
  }
});

test("a heal patch's raster covers only the tiles its stroke reaches, growing with it", async () => {
  const gpu = await init();
  const source = createImageSource(
    target(gpu, { size: [2048, 1536], format: "rgba16float" }),
  );
  const resources = createResources();
  const sourceId = resources.add(new File([], "photo.png"), source);
  const document = createDocument(
    {
      frame: imageFrame(source.image.size),
      layers: [createImageLayer(sourceId, "Photo")],
    },
    resources,
  );
  const renderer = createEditorRenderer(gpu, source);
  const raster = () => renderer.inspect().rasters.map(({ size }) => size);
  try {
    const id = addLayer(document, createLayer("heal"));
    document.history.begin();
    addHealPatch(
      document,
      id,
      { ...dab, size: 30, points: [[1000, 700, 1]] },
      [80, 0],
    );
    await renderer.update(document.scene.getState(), undefined, true);
    // One 256 px tile rather than the whole photo.
    expect(raster()).toEqual([[256, 256]]);
    extendHealPatch(document, id, [[1100, 700, 1]]);
    await renderer.update(document.scene.getState(), undefined, true);
    expect(raster()).toEqual([[512, 256]]);
    document.history.commit();
  } finally {
    renderer.dispose();
    document.dispose();
    gpu.dispose();
  }
});

test("one Healing layer composes its patches in order through render nodes", async () => {
  const gpu = await init();
  const resources = createResources();
  const source = createImageSource(
    target(gpu, { size: [128, 96], format: "rgba16float" }),
  );
  const sourceId = resources.add(new File([], "photo.png"), source);
  const document = createDocument(
    {
      frame: imageFrame(source.image.size),
      layers: [createImageLayer(sourceId, "Photo")],
    },
    resources,
  );
  const renderer = createEditorRenderer(gpu, source);
  try {
    const layer = addLayer(document, createLayer("heal"));
    const stroke: BrushStroke = {
      mode: "paint",
      size: 24,
      feather: 0.4,
      flow: 1,
      points: [[64, 48, 1]],
    };
    const first = addHealPatch(document, layer, stroke, [30, 0]);
    const second = addHealPatch(document, layer, stroke, [-30, 0], "clone");
    expect(patchesOf(document, layer).map((patch) => patch.mode)).toEqual([
      "heal",
      "clone",
    ]);
    await renderer.update(document.scene.getState(), layer);
    expect(renderer.inspect().passes).toContain(
      `layer/${layer}/${first}/blend`,
    );
    expect(renderer.inspect().passes).toContain(
      `layer/${layer}/${second}/blend`,
    );
    await renderer.update(document.scene.getState(), first);
    const firstInput = renderer.inputImage(first);
    expect(firstInput).toBeDefined();
    // A later patch sees the result of the earlier ones.
    await renderer.update(document.scene.getState(), second);
    expect(renderer.inputImage(second)).toBeDefined();
    expect(renderer.inputImage(second)).not.toBe(firstInput);
    const correctionGraph = renderer.inspect();
    expect(
      correctionGraph.passes.filter((name) =>
        name.startsWith(`layer/${layer}/${second}/`),
      ),
    ).toEqual([`layer/${layer}/${second}/blend`]);
    setHealDestination(document, layer, first, [80, 60]);
    setHealPatch(document, layer, first, { feather: 0.2, opacity: 0.6 });
    await renderer.update(document.scene.getState(), second);
    expect(renderer.inspect().passes).toEqual(correctionGraph.passes);
    expect(renderer.inspect().textures).toEqual(correctionGraph.textures);
    const copy = duplicateHealPatch(document, layer, first);
    expect(patchesOf(document, layer)).toMatchObject([
      {
        id: first,
        strokes: [{ points: [[80, 60, 1]], size: 24, feather: 0 }],
        offset: [14, -12],
        feather: 0.2,
        opacity: 0.6,
      },
      { id: copy, offset: [14, -12] },
      { id: second },
    ]);
    deleteHealPatch(document, layer, copy);
    expect(patchesOf(document, layer).map((patch) => patch.id)).toEqual([
      first,
      second,
    ]);
  } finally {
    renderer.dispose();
    document.dispose();
    gpu.dispose();
  }
});

test("a gesture during a finishing stroke joins its undo step", () => {
  const { document, layer } = healFixture();
  try {
    expect(document.history.begin()).toBe(true);
    const patch = addHealPatch(document, layer, dab, [0, 0]);
    // A slider or handle finds the group open and leaves it to the stroke.
    expect(document.history.begin()).toBe(false);
    setHealPatch(document, layer, patch, { feather: 0.5 });
    setHealSource(document, layer, patch, [6, -2]);
    document.history.commit();
    expect(document.history.status.getState()).toMatchObject({
      undoCount: 2,
      editing: false,
    });
    expect(patchesOf(document, layer)[0]).toMatchObject({
      feather: 0.5,
      offset: [6, -2],
    });
    document.history.undo();
    expect(patchesOf(document, layer)).toHaveLength(0);
  } finally {
    document.dispose();
  }
});