feat: Phase 2+3 — ops tests, CI (Linux + macOS matrix)

- fix pict_rotate orientation 6/8: swap CW/CCW formulas (EXIF was inverted)
- add test/ops_precision.ts: 13 cases for rotate/remove_background/round_corners
- fix test/*.ts: platform-aware libpict extension (.dylib/.so)
- add .github/workflows/build.yml: cmake build + bun tests on ubuntu/macos

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: tsukasa-art

.github/workflows/build.yml

@@ -0,0 +1,48 @@
+name: Build & Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    name: ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install dependencies (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -y \
+            cmake pkg-config \
+            libavif-dev libwebp-dev \
+            libjpeg-dev libpng-dev libheif-dev
+
+      - name: Install dependencies (macOS)
+        if: runner.os == 'macOS'
+        run: |
+          brew install libavif webp jpeg-turbo libpng libheif
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Build
+        run: |
+          cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+          cmake --build build --parallel
+
+      - name: Test — Lanczos-3 precision
+        run: bun run test/lanczos_precision.ts
+
+      - name: Test — ops precision
+        run: bun run test/ops_precision.ts

src/pict.c

@@ -473,9 +473,9 @@ uint8_t *pict_rotate(
             case 3: dx = src_w - 1 - sx; dy = src_h - 1 - sy; break;
             case 4: dx = sx; dy = src_h - 1 - sy; break;
             case 5: dx = sy; dy = sx; break;
-            case 6: dx = sy; dy = src_w - 1 - sx; break;
+            case 6: dx = src_h - 1 - sy; dy = sx; break;
             case 7: dx = src_h - 1 - sy; dy = src_w - 1 - sx; break;
-            case 8: dx = src_h - 1 - sy; dy = sx; break;
+            case 8: dx = sy; dy = src_w - 1 - sx; break;
             default: dx = sx; dy = sy; break;
             }
             uint8_t *dp = dst + ((size_t)dy * dw + dx) * ch;

test/diag_c_only.ts

@@ -0,0 +1,48 @@
+// C dylib のみをロードして uniform color resize の正確性を確認
+import { dlopen, FFIType, ptr, toArrayBuffer } from "bun:ffi";
+import { join } from "path";
+
+const C_LIB = join(import.meta.dir, "../build/libpict.dylib");
+
+const lib = dlopen(C_LIB, {
+  pict_resize: {
+    args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u8,
+           FFIType.u32, FFIType.u32, FFIType.u32, FFIType.ptr],
+    returns: FFIType.ptr,
+  },
+  pict_free_buffer: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.void },
+});
+
+// 4×4 RGB uniform (100, 150, 200) → 2×2
+{
+  const src = new Uint8Array(4 * 4 * 3);
+  for (let i = 0; i < 16; i++) { src[i*3]=100; src[i*3+1]=150; src[i*3+2]=200; }
+  const outLen = new BigUint64Array(1);
+  const r = lib.symbols.pict_resize(ptr(src), 4, 4, 3, 2, 2, 1, ptr(outLen));
+  const out = new Uint8Array(toArrayBuffer(r!, 0, Number(outLen[0])).slice(0));
+  lib.symbols.pict_free_buffer(r!, outLen[0]);
+  console.log("4x4 uniform RGB → 2x2:");
+  for (let i = 0; i < 4; i++) console.log(`  [${i}] R=${out[i*3]} G=${out[i*3+1]} B=${out[i*3+2]} (expect 100,150,200)`);
+}
+
+// gradient 64×48 → 64×48 identity: pixel(2,0) should be R=8,G=0,B=5
+{
+  const SRC_W=64, SRC_H=48, CH=3;
+  const src = new Uint8Array(SRC_W * SRC_H * CH);
+  for (let y = 0; y < SRC_H; y++) for (let x = 0; x < SRC_W; x++) {
+    const i = (y*SRC_W+x)*CH;
+    src[i+0] = Math.round(x*255/(SRC_W-1));
+    src[i+1] = Math.round(y*255/(SRC_H-1));
+    src[i+2] = Math.round((x+y)*255/(SRC_W+SRC_H-2));
+  }
+  const outLen = new BigUint64Array(1);
+  const r = lib.symbols.pict_resize(ptr(src), SRC_W, SRC_H, CH, SRC_W, SRC_H, 1, ptr(outLen));
+  const out = new Uint8Array(toArrayBuffer(r!, 0, Number(outLen[0])).slice(0));
+  lib.symbols.pict_free_buffer(r!, outLen[0]);
+  console.log("\n64x48 identity:");
+  console.log(`  (0,0): R=${out[0]} G=${out[1]} B=${out[2]} (src: R=0,G=0,B=0)`);
+  console.log(`  (2,0): R=${out[6]} G=${out[7]} B=${out[8]} (src: R=8,G=0,B=5)`);
+  console.log(`  (0,1): R=${out[SRC_W*3]} G=${out[SRC_W*3+1]} B=${out[SRC_W*3+2]} (src: R=0,G=5,B=2)`);
+}
+
+lib.close();

test/diag_simple.ts

@@ -0,0 +1,49 @@
+// 単純なベリファイ: 4x4 均一色を 2x2 にリサイズして、全ピクセルが同じ値になるか確認
+import { dlopen, FFIType, ptr, toArrayBuffer } from "bun:ffi";
+
+const ZIG_LIB = "/Users/tuki/Develop/Projects/zenpix/npm/zenpix-darwin-arm64/libpict.dylib";
+const C_LIB   = "/Users/tuki/Develop/Projects/zenpix-c/build/libpict.dylib";
+
+function makeLib(path: string) {
+  return dlopen(path, {
+    pict_resize: {
+      args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u8,
+             FFIType.u32, FFIType.u32, FFIType.u32, FFIType.ptr],
+      returns: FFIType.ptr,
+    },
+    pict_free_buffer: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.void },
+  });
+}
+
+const zig = makeLib(ZIG_LIB);
+const c   = makeLib(C_LIB);
+
+// 4x4 RGB, all pixels = (100, 150, 200)
+const src = new Uint8Array(4 * 4 * 3).fill(0);
+for (let i = 0; i < 4*4; i++) { src[i*3]=100; src[i*3+1]=150; src[i*3+2]=200; }
+
+function resize(lib: ReturnType<typeof makeLib>, name: string, srcW: number, srcH: number, dstW: number, dstH: number, ch: number) {
+  const pixels = new Uint8Array(srcW * srcH * ch);
+  for (let y = 0; y < srcH; y++) for (let x = 0; x < srcW; x++) {
+    const i = (y*srcW+x)*ch;
+    pixels[i+0] = 100; if (ch>1) pixels[i+1] = 150; if (ch>2) pixels[i+2] = 200;
+  }
+  const outLen = new BigUint64Array(1);
+  const result = lib.symbols.pict_resize(ptr(pixels), srcW, srcH, ch, dstW, dstH, 1, ptr(outLen));
+  if (!result) { console.log(`${name}: NULL`); return; }
+  const out = new Uint8Array(toArrayBuffer(result, 0, Number(outLen[0])).slice(0));
+  lib.symbols.pict_free_buffer(result, outLen[0]);
+  console.log(`${name} ${srcW}x${srcH} → ${dstW}x${dstH} ch=${ch}:`);
+  for (let i = 0; i < Math.min(dstW*dstH, 4); i++) {
+    if (ch===3) console.log(`  [${i}] R=${out[i*3]} G=${out[i*3+1]} B=${out[i*3+2]}`);
+    else if (ch===1) console.log(`  [${i}] V=${out[i]}`);
+  }
+}
+
+resize(zig, "ZIG", 4, 4, 2, 2, 3);
+resize(c,   "C  ", 4, 4, 2, 2, 3);
+console.log("---");
+resize(zig, "ZIG", 4, 4, 2, 2, 1);
+resize(c,   "C  ", 4, 4, 2, 2, 1);
+
+zig.close(); c.close();

test/diag_zig.ts

@@ -0,0 +1,55 @@
+import { dlopen, FFIType, ptr, toArrayBuffer } from "bun:ffi";
+
+const ZIG_LIB = "/Users/tuki/Develop/Projects/zenpix/npm/zenpix-darwin-arm64/libpict.dylib";
+const C_LIB   = "/Users/tuki/Develop/Projects/zenpix-c/build/libpict.dylib";
+
+function makeLib(path: string) {
+  return dlopen(path, {
+    pict_resize: {
+      args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u8,
+             FFIType.u32, FFIType.u32, FFIType.u32, FFIType.ptr],
+      returns: FFIType.ptr,
+    },
+    pict_free_buffer: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.void },
+  });
+}
+
+const SRC_W = 64, SRC_H = 48, CH = 3;
+const src = new Uint8Array(SRC_W * SRC_H * CH);
+for (let y = 0; y < SRC_H; y++)
+  for (let x = 0; x < SRC_W; x++) {
+    const i = (y * SRC_W + x) * CH;
+    src[i+0] = Math.round(x * 255 / (SRC_W-1));
+    src[i+1] = Math.round(y * 255 / (SRC_H-1));
+    src[i+2] = Math.round((x+y) * 255 / (SRC_W+SRC_H-2));
+  }
+
+console.log("Source pixel (2,0): R=%d G=%d B=%d", src[6], src[7], src[8]);
+
+function doResize(lib: ReturnType<typeof makeLib>, name: string, dstW: number, dstH: number) {
+  const outLen = new BigUint64Array(1);
+  const result = lib.symbols.pict_resize(ptr(src), SRC_W, SRC_H, CH, dstW, dstH, 1, ptr(outLen));
+  if (!result) { console.log(`${name} ${dstW}x${dstH}: NULL`); return; }
+  const got = new Uint8Array(toArrayBuffer(result, 0, Number(outLen[0])).slice(0));
+  lib.symbols.pict_free_buffer(result, outLen[0]);
+  // print first 6 pixels
+  for (let i = 0; i < 6; i++) {
+    const R = got[i*3], G = got[i*3+1], B = got[i*3+2];
+    const x = i % dstW, y = Math.floor(i / dstW);
+    console.log(`  ${name} (${x},${y}): R=${R} G=${G} B=${B}`);
+  }
+}
+
+const zig = makeLib(ZIG_LIB);
+const c   = makeLib(C_LIB);
+
+console.log("\n--- identity 64x48 → 64x48 ---");
+doResize(zig, "ZIG", 64, 48);
+doResize(c,   "C  ", 64, 48);
+
+console.log("\n--- downscale 64x48 → 20x15 ---");
+doResize(zig, "ZIG", 20, 15);
+doResize(c,   "C  ", 20, 15);
+
+zig.close();
+c.close();

test/generate_reference.ts

@@ -0,0 +1,82 @@
+/**
+ * generate_reference.ts — one-time script to produce reference_data.bin
+ *
+ * Uses the Zig-built libpict.dylib to generate ground-truth resize output.
+ * Commit the resulting reference_data.bin; future CI uses it without Zig.
+ *
+ * Run: bun run test/generate_reference.ts
+ */
+
+import { dlopen, FFIType, ptr, toArrayBuffer } from "bun:ffi";
+import { writeFileSync } from "fs";
+import { join } from "path";
+
+const ZIG_LIB = "/Users/tuki/Develop/Projects/zenpix/npm/zenpix-darwin-arm64/libpict.dylib";
+
+const lib = dlopen(ZIG_LIB, {
+  pict_resize: {
+    args: [FFIType.ptr, FFIType.u32, FFIType.u32, FFIType.u8,
+           FFIType.u32, FFIType.u32, FFIType.u32, FFIType.ptr],
+    returns: FFIType.ptr,
+  },
+  pict_free_buffer: {
+    args: [FFIType.ptr, FFIType.u64],
+    returns: FFIType.void,
+  },
+});
+
+// ── Synthetic input: 64×48 RGB gradient ──────────────────────────────────────
+const SRC_W = 64, SRC_H = 48, CH = 3;
+const src = new Uint8Array(SRC_W * SRC_H * CH);
+for (let y = 0; y < SRC_H; y++) {
+  for (let x = 0; x < SRC_W; x++) {
+    const i = (y * SRC_W + x) * CH;
+    src[i + 0] = Math.round(x * 255 / (SRC_W - 1));               // R: left→right
+    src[i + 1] = Math.round(y * 255 / (SRC_H - 1));               // G: top→bottom
+    src[i + 2] = Math.round((x + y) * 255 / (SRC_W + SRC_H - 2));// B: diagonal
+  }
+}
+
+// ── Resize cases ──────────────────────────────────────────────────────────────
+const cases = [
+  { dstW: 20,  dstH: 15, label: "64×48 → 20×15  (downscale ×0.3)" },
+  { dstW: 128, dstH: 96, label: "64×48 → 128×96 (upscale ×2)" },
+  { dstW: 64,  dstH: 48, label: "64×48 → 64×48  (identity)" },
+];
+
+// ── Generate ──────────────────────────────────────────────────────────────────
+const parts: Buffer[] = [];
+
+const countBuf = Buffer.alloc(4);
+countBuf.writeUInt32LE(cases.length, 0);
+parts.push(countBuf);
+
+for (const { dstW, dstH, label } of cases) {
+  const outLen = new BigUint64Array(1);
+  const result = lib.symbols.pict_resize(
+    ptr(src), SRC_W, SRC_H, CH,
+    dstW, dstH,
+    1,           // n_threads = 1 (deterministic)
+    ptr(outLen),
+  );
+  if (!result) throw new Error(`Zig pict_resize failed: ${label}`);
+
+  const pixels = new Uint8Array(toArrayBuffer(result, 0, Number(outLen[0])).slice(0));
+  lib.symbols.pict_free_buffer(result, outLen[0]);
+
+  const header = Buffer.alloc(16);
+  header.writeUInt32LE(dstW, 0);
+  header.writeUInt32LE(dstH, 4);
+  header.writeUInt32LE(CH, 8);
+  header.writeUInt32LE(pixels.length, 12);
+
+  parts.push(header, Buffer.from(pixels));
+  console.log(`  ${label}: ${pixels.length} bytes`);
+}
+
+lib.close();
+
+// ── Write ─────────────────────────────────────────────────────────────────────
+const outPath = join(import.meta.dir, "reference_data.bin");
+writeFileSync(outPath, Buffer.concat(parts));
+console.log(`\nSaved ${outPath}`);