@lumy-pack/scene-sieve 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -15,7 +15,8 @@ var logger = {
     console.log(`${pc.blue("info")} ${message}`);
   },
   success(message) {
-    console.log(`${pc.green("done")} ${message}`);
+    console.log(`
+${pc.green("done")} ${message}`);
   },
   warn(message) {
     console.warn(`${pc.yellow("warn")} ${message}`);
@@ -38,10 +39,12 @@ import sharp from "sharp";
 import { tmpdir } from "os";
 import { join } from "path";
 var APP_NAME = "scene-sieve";
-var DEFAULT_COUNT = 5;
+var DEFAULT_COUNT = 20;
+var DEFAULT_THRESHOLD = 0.5;
 var DEFAULT_FPS = 5;
 var DEFAULT_SCALE = 720;
 var DEFAULT_QUALITY = 80;
+var NORMALIZATION_PERCENTILE = 0.9;
 var WORKSPACE_PREFIX = `${APP_NAME}-`;
 var TEMP_BASE_DIR = tmpdir();
 var SUPPORTED_VIDEO_EXTENSIONS = [
@@ -61,6 +64,10 @@ var IOU_THRESHOLD = 0.9;
 var DECAY_LAMBDA = 0.95;
 var ANIMATION_FRAME_THRESHOLD = 5;
 var MATCH_DISTANCE_THRESHOLD = 0.75;
+var PIXELDIFF_GAUSSIAN_KERNEL = 3;
+var PIXELDIFF_BINARY_THRESHOLD = 30;
+var PIXELDIFF_CONTOUR_MIN_AREA = 100;
+var PIXELDIFF_SAMPLE_SPACING = 8;
 function getTempWorkspaceDir(sessionId) {
   return join(TEMP_BASE_DIR, `${WORKSPACE_PREFIX}${sessionId}`);
 }
@@ -320,6 +327,60 @@ async function computeAKAZEDiff(cvLib, frame1, frame2) {
     if (matches) matches.delete();
   }
 }
+function computePixelDiff(cvLib, frame1, frame2) {
+  const cv = cvLib;
+  const mat1 = new cv.Mat(frame1.height, frame1.width, cv.CV_8UC1);
+  const mat2 = new cv.Mat(frame2.height, frame2.width, cv.CV_8UC1);
+  const diff = new cv.Mat();
+  const blurred = new cv.Mat();
+  const binary = new cv.Mat();
+  const contours = new cv.MatVector();
+  const hierarchy = new cv.Mat();
+  try {
+    mat1.data.set(frame1.data);
+    mat2.data.set(frame2.data);
+    cv.absdiff(mat1, mat2, diff);
+    const ksize = new cv.Size(
+      PIXELDIFF_GAUSSIAN_KERNEL,
+      PIXELDIFF_GAUSSIAN_KERNEL
+    );
+    cv.GaussianBlur(diff, blurred, ksize, 0);
+    cv.threshold(
+      blurred,
+      binary,
+      PIXELDIFF_BINARY_THRESHOLD,
+      255,
+      cv.THRESH_BINARY
+    );
+    cv.findContours(
+      binary,
+      contours,
+      hierarchy,
+      cv.RETR_EXTERNAL,
+      cv.CHAIN_APPROX_SIMPLE
+    );
+    const points = [];
+    for (let c = 0; c < contours.size(); c++) {
+      const contour = contours.get(c);
+      const rect = cv.boundingRect(contour);
+      if (rect.width * rect.height < PIXELDIFF_CONTOUR_MIN_AREA) continue;
+      for (let y = rect.y; y < rect.y + rect.height; y += PIXELDIFF_SAMPLE_SPACING) {
+        for (let x = rect.x; x < rect.x + rect.width; x += PIXELDIFF_SAMPLE_SPACING) {
+          points.push({ x, y });
+        }
+      }
+    }
+    return points;
+  } finally {
+    mat1.delete();
+    mat2.delete();
+    diff.delete();
+    blurred.delete();
+    binary.delete();
+    contours.delete();
+    hierarchy.delete();
+  }
+}
 function computeInformationGain(clusters, clusterPoints, imageArea, animationIndices, animationWeights) {
   if (clusters.length === 0) return 0;
   let gain = 0;
@@ -354,8 +415,28 @@ async function analyzeBatch(cvLib, frames, scale, tracker, pairOffset) {
         preprocessed[i],
         preprocessed[i + 1]
       );
-      const dbscanResult = dbscan(sNew, imageWidth, imageHeight);
-      const clusters = dbscanResult.boundingBoxes;
+      let dbscanResult = dbscan(sNew, imageWidth, imageHeight);
+      let clusters = dbscanResult.boundingBoxes;
+      if (clusters.length === 0) {
+        const pixelDiffPoints = computePixelDiff(
+          cvLib,
+          preprocessed[i],
+          preprocessed[i + 1]
+        );
+        if (pixelDiffPoints.length > 0) {
+          logger.debug(
+            `Edge ${frames[i].id}->${frames[i + 1].id}: pixel-diff fallback (${pixelDiffPoints.length} points)`
+          );
+          dbscanResult = dbscan(
+            pixelDiffPoints,
+            imageWidth,
+            imageHeight,
+            void 0,
+            2
+          );
+          clusters = dbscanResult.boundingBoxes;
+        }
+      }
       const clusterPointCounts = new Array(clusters.length).fill(0);
       for (const label of dbscanResult.labels) {
         if (label >= 0) {
@@ -373,7 +454,9 @@ async function analyzeBatch(cvLib, frames, scale, tracker, pairOffset) {
         animationIndices,
         animationWeights
       );
-      logger.debug(`Edge ${frames[i].id}->${frames[i + 1].id} G(t)=${score.toFixed(6)}`);
+      logger.debug(
+        `Edge ${frames[i].id}->${frames[i + 1].id} G(t)=${score.toFixed(6)}`
+      );
       edges.push({
         sourceId: frames[i].id,
         targetId: frames[i + 1].id,
@@ -418,12 +501,13 @@ async function analyzeFrames(ctx) {
 // src/core/extractor.ts
 import { readdir } from "fs/promises";
 import { join as join2 } from "path";
-import ffmpeg from "fluent-ffmpeg";
-import ffmpegStatic from "ffmpeg-static";
 import { path as ffprobePath } from "@ffprobe-installer/ffprobe";
+import { execa } from "execa";
+import ffmpegPath from "ffmpeg-static";
 
 // src/utils/paths.ts
 import { mkdir, stat } from "fs/promises";
+import { homedir } from "os";
 import { basename, extname, resolve } from "path";
 async function ensureDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
@@ -436,6 +520,16 @@ async function fileExists(filePath) {
     return false;
   }
 }
+function expandTilde(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) {
+    return resolve(homedir(), p.slice(2));
+  }
+  return p;
+}
+function resolveAbsolute(p) {
+  return resolve(expandTilde(p));
+}
 function deriveOutputPath(inputPath) {
   const dir = resolve(inputPath, "..");
   const name = basename(inputPath, extname(inputPath));
@@ -446,8 +540,6 @@ function isSupportedFile(filePath, extensions) {
 }
 
 // src/core/extractor.ts
-if (ffmpegStatic) ffmpeg.setFfmpegPath(ffmpegStatic);
-ffmpeg.setFfprobePath(ffprobePath);
 async function extractFrames(ctx) {
   const framesDir = join2(ctx.workspacePath, "frames");
   const { inputPath, fps, scale } = ctx.options;
@@ -458,7 +550,10 @@ async function extractFrames(ctx) {
   if (!exists) {
     throw new Error(`Input file not found: ${inputPath}`);
   }
-  const allExtensions = [...SUPPORTED_VIDEO_EXTENSIONS, ...SUPPORTED_GIF_EXTENSIONS];
+  const allExtensions = [
+    ...SUPPORTED_VIDEO_EXTENSIONS,
+    ...SUPPORTED_GIF_EXTENSIONS
+  ];
   if (!isSupportedFile(inputPath, allExtensions)) {
     throw new Error(`Unsupported file format: ${inputPath}`);
   }
@@ -484,35 +579,43 @@ async function extractFrames(ctx) {
 }
 async function extractIFrames(inputPath, outputDir, scale) {
   const outputPattern = join2(outputDir, "frame_%06d.jpg");
-  await new Promise((resolve2, reject) => {
-    ffmpeg(inputPath).outputOptions([
-      `-vf select='eq(pict_type,I)',scale=-1:${scale}`,
-      "-vsync vfr",
-      "-q:v 2"
-    ]).output(outputPattern).on("end", () => resolve2()).on("error", (err) => reject(err)).run();
-  });
+  await execa(ffmpegPath, [
+    "-i",
+    inputPath,
+    "-vf",
+    `select='eq(pict_type,I)',scale=-1:${scale}`,
+    "-vsync",
+    "vfr",
+    "-q:v",
+    "2",
+    outputPattern
+  ]);
   return buildFrameList(outputDir, inputPath);
 }
 async function extractByFps(inputPath, outputDir, fps, scale) {
   const outputPattern = join2(outputDir, "frame_%06d.jpg");
-  await new Promise((resolve2, reject) => {
-    ffmpeg(inputPath).outputOptions([
-      `-vf fps=${fps},scale=-1:${scale}`,
-      "-q:v 2"
-    ]).output(outputPattern).on("end", () => resolve2()).on("error", (err) => reject(err)).run();
-  });
+  await execa(ffmpegPath, [
+    "-i",
+    inputPath,
+    "-vf",
+    `fps=${fps},scale=-1:${scale}`,
+    "-q:v",
+    "2",
+    outputPattern
+  ]);
   return buildFrameList(outputDir, inputPath);
 }
 async function getVideoDuration(inputPath) {
-  return new Promise((resolve2, reject) => {
-    ffmpeg.ffprobe(inputPath, (err, metadata) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve2(metadata.format.duration ?? 0);
-    });
-  });
+  const { stdout } = await execa(ffprobePath, [
+    "-v",
+    "quiet",
+    "-print_format",
+    "json",
+    "-show_format",
+    inputPath
+  ]);
+  const metadata = JSON.parse(stdout);
+  return parseFloat(metadata.format?.duration ?? "0");
 }
 async function buildFrameList(framesDir, inputPath) {
   const files = await readdir(framesDir);
@@ -524,7 +627,9 @@ async function buildFrameList(framesDir, inputPath) {
   try {
     duration = await getVideoDuration(inputPath);
   } catch {
-    logger.debug("Could not determine video duration; using frame index for timestamps");
+    logger.debug(
+      "Could not determine video duration; using frame index for timestamps"
+    );
   }
   return jpgFiles.map((file, index) => ({
     id: index,
@@ -599,17 +704,15 @@ async function readFramesAsBuffers(frameNodes, quality) {
 // src/core/input-resolver.ts
 function resolveOptions(options) {
   const mode = options.mode;
-  const inputPath = mode === "file" ? options.inputPath : void 0;
+  const inputPath = mode === "file" ? resolveAbsolute(options.inputPath) : void 0;
   const outputPath = options.outputPath ?? (inputPath ? deriveOutputPath(inputPath) : join4(process.cwd(), "scene-sieve-output"));
-  const threshold = options.threshold;
-  if (threshold !== void 0 && (threshold <= 0 || threshold > 1)) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  if (threshold <= 0 || threshold > 1) {
     throw new Error(
       `threshold must be in range (0, 1], received: ${threshold}`
     );
   }
-  const hasThreshold = threshold !== void 0;
-  const hasExplicitCount = options.count !== void 0;
-  const pruneMode = hasThreshold && hasExplicitCount ? "threshold-with-cap" : hasThreshold ? "threshold" : "count";
+  const pruneMode = "threshold-with-cap";
   return {
     mode,
     inputPath,
@@ -625,10 +728,16 @@ function resolveOptions(options) {
 }
 async function resolveInput(options, workspacePath) {
   if (options.mode === "file") {
-    return { frames: [], resolvedInputPath: options.inputPath };
+    return {
+      frames: [],
+      resolvedInputPath: resolveAbsolute(options.inputPath)
+    };
   }
   if (options.mode === "buffer") {
-    const resolvedInputPath = await writeInputBuffer(options.inputBuffer, workspacePath);
+    const resolvedInputPath = await writeInputBuffer(
+      options.inputBuffer,
+      workspacePath
+    );
     return { frames: [], resolvedInputPath };
   }
   if (options.mode === "frames") {
@@ -697,7 +806,11 @@ function pruneTo(graph, frames, targetCount) {
   const heap = new MinHeap();
   for (const edge of graph) {
     edgeScore.set(`${edge.sourceId}:${edge.targetId}`, edge.score);
-    heap.push({ score: edge.score, srcId: edge.sourceId, tgtId: edge.targetId });
+    heap.push({
+      score: edge.score,
+      srcId: edge.sourceId,
+      tgtId: edge.targetId
+    });
   }
   const surviving = new Set(frames.map((f) => f.id));
   const firstId = frames[0].id;
@@ -733,9 +846,55 @@ function normalizeScores(graph) {
   const safeScores = graph.map(
     (e) => Number.isFinite(e.score) && e.score > 0 ? e.score : 0
   );
-  const maxScore = Math.max(...safeScores);
-  if (maxScore === 0) return safeScores;
-  return safeScores.map((s) => s / maxScore);
+  const sorted = [...safeScores].filter((s) => s > 0).sort((a, b) => a - b);
+  if (sorted.length === 0) return safeScores;
+  const pIdx = Math.min(
+    Math.floor(sorted.length * NORMALIZATION_PERCENTILE),
+    sorted.length - 1
+  );
+  const refScore = sorted[pIdx];
+  return safeScores.map((s) => Math.min(s / refScore, 1));
+}
+function suppressConsecutiveRuns(graph, passingIndices, normalizedScores) {
+  const result = /* @__PURE__ */ new Set();
+  let runStart = 0;
+  while (runStart < passingIndices.length) {
+    let runEnd = runStart;
+    while (runEnd + 1 < passingIndices.length && passingIndices[runEnd + 1] === passingIndices[runEnd] + 1) {
+      runEnd++;
+    }
+    const runLen = runEnd - runStart + 1;
+    if (runLen === 1) {
+      result.add(graph[passingIndices[runStart]].targetId);
+    } else {
+      const peaks = [];
+      for (let j = runStart; j <= runEnd; j++) {
+        const idx = passingIndices[j];
+        const score = normalizedScores[idx];
+        const prevScore = j > runStart ? normalizedScores[passingIndices[j - 1]] : -Infinity;
+        const nextScore = j < runEnd ? normalizedScores[passingIndices[j + 1]] : -Infinity;
+        if (score > prevScore && score > nextScore) {
+          peaks.push(idx);
+        }
+      }
+      if (peaks.length > 0) {
+        for (const peakIdx of peaks) {
+          result.add(graph[peakIdx].targetId);
+        }
+      } else {
+        let peakIdx = passingIndices[runStart];
+        for (let j = runStart + 1; j <= runEnd; j++) {
+          const idx = passingIndices[j];
+          if (normalizedScores[idx] > normalizedScores[peakIdx]) {
+            peakIdx = idx;
+          }
+        }
+        result.add(graph[peakIdx].targetId);
+      }
+    }
+    runStart = runEnd + 1;
+  }
+  return result;
 }
 function pruneByThreshold(graph, frames, threshold) {
   if (frames.length === 0) return /* @__PURE__ */ new Set();
@@ -743,11 +902,16 @@ function pruneByThreshold(graph, frames, threshold) {
   surviving.add(frames[0].id);
   surviving.add(frames[frames.length - 1].id);
   const normalized = normalizeScores(graph);
+  const passingIndices = [];
   for (let i = 0; i < graph.length; i++) {
     if (normalized[i] >= threshold) {
-      surviving.add(graph[i].targetId);
+      passingIndices.push(i);
     }
   }
+  const nmsTargets = suppressConsecutiveRuns(graph, passingIndices, normalized);
+  for (const id of nmsTargets) {
+    surviving.add(id);
+  }
   return surviving;
 }
 function pruneByThresholdWithCap(graph, frames, threshold, maxCount) {
@@ -831,35 +995,22 @@ async function runPipeline(options) {
     ctx.status = "ANALYZING";
     ctx.graph = await analyzeFrames(ctx);
     ctx.status = "PRUNING";
-    let survivingIds;
-    switch (resolvedOptions.pruneMode) {
-      case "threshold-with-cap":
-        survivingIds = pruneByThresholdWithCap(
-          ctx.graph,
-          ctx.frames,
-          resolvedOptions.threshold,
-          resolvedOptions.count
-        );
-        break;
-      case "threshold":
-        survivingIds = pruneByThreshold(
-          ctx.graph,
-          ctx.frames,
-          resolvedOptions.threshold
-        );
-        break;
-      case "count":
-      default:
-        survivingIds = pruneTo(ctx.graph, ctx.frames, resolvedOptions.count);
-        break;
-    }
+    const survivingIds = pruneByThresholdWithCap(
+      ctx.graph,
+      ctx.frames,
+      resolvedOptions.threshold,
+      resolvedOptions.count
+    );
     const prunedFrames = ctx.frames.filter((f) => survivingIds.has(f.id));
     ctx.emitProgress(100);
     ctx.status = "FINALIZING";
     let outputFiles = [];
     let outputBuffers;
     if (resolvedOptions.mode === "buffer" || resolvedOptions.mode === "frames") {
-      outputBuffers = await readFramesAsBuffers(prunedFrames, resolvedOptions.quality);
+      outputBuffers = await readFramesAsBuffers(
+        prunedFrames,
+        resolvedOptions.quality
+      );
       ctx.emitProgress(100);
     } else {
       outputFiles = await finalizeOutput(ctx, prunedFrames);

package/dist/types/index.d.ts

@@ -24,8 +24,8 @@ export interface ResolvedOptions {
     mode: 'file' | 'buffer' | 'frames';
     inputPath?: string;
     count: number;
-    threshold?: number;
-    pruneMode: 'count' | 'threshold' | 'threshold-with-cap';
+    threshold: number;
+    pruneMode: 'threshold-with-cap';
     outputPath: string;
     fps: number;
     scale: number;

package/dist/utils/paths.d.ts

@@ -1,5 +1,15 @@
 export declare function ensureDir(dirPath: string): Promise<void>;
 export declare function fileExists(filePath: string): Promise<boolean>;
+/**
+ * Expand leading ~ to homedir. Node's path.resolve() does not expand ~,
+ * so paths like ~/Desktop/foo depend on process.cwd() and can produce
+ * different results when run from different directories.
+ */
+export declare function expandTilde(p: string): string;
+/**
+ * Resolve path to absolute. Expands ~ to homedir first so that the result
+ * does not depend on process.cwd().
+ */
 export declare function resolveAbsolute(p: string): string;
 /**
  * Derive default output directory name from input file path.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumy-pack/scene-sieve",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "CLI tool for extracting key frames from video and GIF files",
   "keywords": [
     "cli",
@@ -58,15 +58,14 @@
     "@techstark/opencv-js": "4.12.0-release.1",
     "cli-progress": "^3.12.0",
     "commander": "^12.1.0",
+    "execa": "^9.5.0",
     "ffmpeg-static": "^5.2.0",
-    "fluent-ffmpeg": "^2.1.3",
     "ora": "^8.0.0",
     "picocolors": "^1.1.1",
     "sharp": "^0.33.0"
   },
   "devDependencies": {
     "@types/cli-progress": "^3.11.6",
-    "@types/fluent-ffmpeg": "^2.1.27",
     "@types/node": "^20.11.0",
     "@vitest/coverage-v8": "^3.2.4"
   }