@lumy-pack/scene-sieve 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -78,10 +78,12 @@ var import_sharp = __toESM(require("sharp"), 1);
 var import_node_os = require("os");
 var import_node_path = require("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 = (0, import_node_os.tmpdir)();
 var SUPPORTED_VIDEO_EXTENSIONS = [
@@ -101,6 +103,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 (0, import_node_path.join)(TEMP_BASE_DIR, `${WORKSPACE_PREFIX}${sessionId}`);
 }
@@ -360,6 +366,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;
@@ -394,8 +454,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) {
@@ -413,7 +493,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,
@@ -458,9 +540,9 @@ async function analyzeFrames(ctx) {
 // src/core/extractor.ts
 var import_promises2 = require("fs/promises");
 var import_node_path3 = require("path");
-var import_fluent_ffmpeg = __toESM(require("fluent-ffmpeg"), 1);
-var import_ffmpeg_static = __toESM(require("ffmpeg-static"), 1);
 var import_ffprobe = require("@ffprobe-installer/ffprobe");
+var import_execa = require("execa");
+var import_ffmpeg_static = __toESM(require("ffmpeg-static"), 1);
 
 // src/utils/paths.ts
 var import_promises = require("fs/promises");
@@ -486,8 +568,6 @@ function isSupportedFile(filePath, extensions) {
 }
 
 // src/core/extractor.ts
-if (import_ffmpeg_static.default) import_fluent_ffmpeg.default.setFfmpegPath(import_ffmpeg_static.default);
-import_fluent_ffmpeg.default.setFfprobePath(import_ffprobe.path);
 async function extractFrames(ctx) {
   const framesDir = (0, import_node_path3.join)(ctx.workspacePath, "frames");
   const { inputPath, fps, scale } = ctx.options;
@@ -498,7 +578,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}`);
   }
@@ -524,35 +607,43 @@ async function extractFrames(ctx) {
 }
 async function extractIFrames(inputPath, outputDir, scale) {
   const outputPattern = (0, import_node_path3.join)(outputDir, "frame_%06d.jpg");
-  await new Promise((resolve2, reject) => {
-    (0, import_fluent_ffmpeg.default)(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 (0, import_execa.execa)(import_ffmpeg_static.default, [
+    "-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 = (0, import_node_path3.join)(outputDir, "frame_%06d.jpg");
-  await new Promise((resolve2, reject) => {
-    (0, import_fluent_ffmpeg.default)(inputPath).outputOptions([
-      `-vf fps=${fps},scale=-1:${scale}`,
-      "-q:v 2"
-    ]).output(outputPattern).on("end", () => resolve2()).on("error", (err) => reject(err)).run();
-  });
+  await (0, import_execa.execa)(import_ffmpeg_static.default, [
+    "-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) => {
-    import_fluent_ffmpeg.default.ffprobe(inputPath, (err, metadata) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve2(metadata.format.duration ?? 0);
-    });
-  });
+  const { stdout } = await (0, import_execa.execa)(import_ffprobe.path, [
+    "-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 (0, import_promises2.readdir)(framesDir);
@@ -564,7 +655,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,
@@ -641,15 +734,13 @@ function resolveOptions(options) {
   const mode = options.mode;
   const inputPath = mode === "file" ? options.inputPath : void 0;
   const outputPath = options.outputPath ?? (inputPath ? deriveOutputPath(inputPath) : (0, import_node_path5.join)(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,
@@ -668,7 +759,10 @@ async function resolveInput(options, workspacePath) {
     return { frames: [], resolvedInputPath: 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") {
@@ -737,7 +831,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;
@@ -773,9 +871,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();
@@ -783,11 +927,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) {
@@ -871,35 +1020,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);