@mevdragon/vidfarm-devcli 0.2.0 → 0.2.1

package/templates/template_0000/src/lib/images.js

@@ -0,0 +1,242 @@
+import sharp from "sharp";
+export async function normalizeToPortraitFrame(input, target = { width: 1080, height: 1920 }) {
+    const buffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+    const oriented = sharp(buffer, { density: 144 }).rotate();
+    const trimmed = await trimFlatBorders(oriented);
+    const targetAspect = target.width / target.height;
+    // If the model already returned a near-native vertical frame, avoid the
+    // activity crop pass because it can misread low-detail edges as padding.
+    const shouldPreserveFraming = await isCloseToAspect(trimmed, targetAspect, 0.025);
+    const cropped = shouldPreserveFraming ? trimmed : await cropToActiveImageRegion(trimmed);
+    const portraitCrop = await cropToPortraitAspect(cropped, targetAspect);
+    const output = await portraitCrop
+        .resize(target.width, target.height, {
+        fit: "cover",
+        position: sharp.strategy.attention
+    })
+        .png()
+        .toBuffer();
+    const exact = await ensureExactPixelSize(output, target);
+    return {
+        bytes: exact,
+        contentType: "image/png",
+        width: target.width,
+        height: target.height
+    };
+}
+async function isCloseToAspect(image, targetAspect, tolerance) {
+    const metadata = await image.metadata();
+    const width = metadata.width ?? 0;
+    const height = metadata.height ?? 0;
+    if (!width || !height) {
+        return false;
+    }
+    return Math.abs(width / height - targetAspect) <= tolerance;
+}
+async function trimFlatBorders(image) {
+    const metadata = await image.metadata();
+    const sourceWidth = metadata.width ?? 0;
+    const sourceHeight = metadata.height ?? 0;
+    if (!sourceWidth || !sourceHeight || sourceWidth < 3 || sourceHeight < 3) {
+        return image;
+    }
+    const { data, info } = await image
+        .clone()
+        .trim({ threshold: 16 })
+        .png()
+        .toBuffer({ resolveWithObject: true });
+    const widthRatio = info.width / sourceWidth;
+    const heightRatio = info.height / sourceHeight;
+    if (widthRatio > 0.985 && heightRatio > 0.985) {
+        return image;
+    }
+    return sharp(data).rotate();
+}
+async function cropToActiveImageRegion(image) {
+    const metadata = await image.metadata();
+    const sourceWidth = metadata.width ?? 0;
+    const sourceHeight = metadata.height ?? 0;
+    if (!sourceWidth || !sourceHeight) {
+        return image;
+    }
+    const sampleWidth = 96;
+    const sampleHeight = 170;
+    const sample = await image
+        .clone()
+        .resize(sampleWidth, sampleHeight, { fit: "fill" })
+        .grayscale()
+        .raw()
+        .toBuffer();
+    const bounds = detectActiveBounds(sample, sampleWidth, sampleHeight);
+    if (!bounds) {
+        return image;
+    }
+    const left = Math.max(0, Math.floor((bounds.left / sampleWidth) * sourceWidth));
+    const top = Math.max(0, Math.floor((bounds.top / sampleHeight) * sourceHeight));
+    const width = Math.min(sourceWidth - left, Math.max(1, Math.ceil((bounds.width / sampleWidth) * sourceWidth)));
+    const height = Math.min(sourceHeight - top, Math.max(1, Math.ceil((bounds.height / sampleHeight) * sourceHeight)));
+    return image.extract({ left, top, width, height });
+}
+async function cropToPortraitAspect(image, targetAspect) {
+    const metadata = await image.metadata();
+    const sourceWidth = metadata.width ?? 0;
+    const sourceHeight = metadata.height ?? 0;
+    if (!sourceWidth || !sourceHeight) {
+        return image;
+    }
+    const sourceAspect = sourceWidth / sourceHeight;
+    if (Math.abs(sourceAspect - targetAspect) < 0.015) {
+        return image;
+    }
+    const focus = await detectFocusPoint(image, sourceWidth, sourceHeight);
+    if (sourceAspect > targetAspect) {
+        const cropWidth = Math.max(1, Math.min(sourceWidth, Math.round(sourceHeight * targetAspect)));
+        const left = clamp(Math.round(focus.x - cropWidth / 2), 0, sourceWidth - cropWidth);
+        return image.extract({ left, top: 0, width: cropWidth, height: sourceHeight });
+    }
+    const cropHeight = Math.max(1, Math.min(sourceHeight, Math.round(sourceWidth / targetAspect)));
+    const top = clamp(Math.round(focus.y - cropHeight / 2), 0, sourceHeight - cropHeight);
+    return image.extract({ left: 0, top, width: sourceWidth, height: cropHeight });
+}
+function detectActiveBounds(sample, width, height) {
+    const rowActivity = new Array(height).fill(0);
+    const colActivity = new Array(width).fill(0);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const index = y * width + x;
+            const current = sample[index] ?? 0;
+            const left = x > 0 ? sample[index - 1] ?? current : current;
+            const up = y > 0 ? sample[index - width] ?? current : current;
+            const right = x < width - 1 ? sample[index + 1] ?? current : current;
+            const down = y < height - 1 ? sample[index + width] ?? current : current;
+            const energy = Math.abs(current - left) +
+                Math.abs(current - right) +
+                Math.abs(current - up) +
+                Math.abs(current - down);
+            rowActivity[y] += energy;
+            colActivity[x] += energy;
+        }
+    }
+    const smoothedRows = smoothSeries(rowActivity.map((value) => value / width), 9);
+    const smoothedCols = smoothSeries(colActivity.map((value) => value / height), 7);
+    const rowBounds = findActiveRange(smoothedRows, Math.round(height * 0.18));
+    const colBounds = findActiveRange(smoothedCols, Math.round(width * 0.16));
+    if (!rowBounds || !colBounds) {
+        return null;
+    }
+    const topMargin = rowBounds.start / height;
+    const bottomMargin = (height - rowBounds.end - 1) / height;
+    const leftMargin = colBounds.start / width;
+    const rightMargin = (width - colBounds.end - 1) / width;
+    const croppedWidth = colBounds.end - colBounds.start + 1;
+    const croppedHeight = rowBounds.end - rowBounds.start + 1;
+    const croppedAreaRatio = (croppedWidth * croppedHeight) / (width * height);
+    const significantMargins = topMargin > 0.11 || bottomMargin > 0.11 || leftMargin > 0.08 || rightMargin > 0.08;
+    if (!significantMargins && croppedAreaRatio > 0.9) {
+        return null;
+    }
+    return {
+        left: colBounds.start,
+        top: rowBounds.start,
+        width: croppedWidth,
+        height: croppedHeight
+    };
+}
+async function detectFocusPoint(image, sourceWidth, sourceHeight) {
+    const sampleWidth = 120;
+    const sampleHeight = Math.max(1, Math.round((sourceHeight / Math.max(sourceWidth, 1)) * sampleWidth));
+    const sample = await image
+        .clone()
+        .resize(sampleWidth, sampleHeight, { fit: "fill" })
+        .grayscale()
+        .raw()
+        .toBuffer();
+    let weightedX = 0;
+    let weightedY = 0;
+    let totalWeight = 0;
+    for (let y = 0; y < sampleHeight; y += 1) {
+        for (let x = 0; x < sampleWidth; x += 1) {
+            const index = y * sampleWidth + x;
+            const current = sample[index] ?? 0;
+            const left = x > 0 ? sample[index - 1] ?? current : current;
+            const up = y > 0 ? sample[index - sampleWidth] ?? current : current;
+            const right = x < sampleWidth - 1 ? sample[index + 1] ?? current : current;
+            const down = y < sampleHeight - 1 ? sample[index + sampleWidth] ?? current : current;
+            const energy = Math.abs(current - left) +
+                Math.abs(current - right) +
+                Math.abs(current - up) +
+                Math.abs(current - down);
+            const centerBiasX = 1 - Math.abs((x + 0.5) / sampleWidth - 0.5) * 0.45;
+            const centerBiasY = 1 - Math.abs((y + 0.5) / sampleHeight - 0.5) * 0.35;
+            const weight = Math.max(energy, 1) * centerBiasX * centerBiasY;
+            weightedX += (x + 0.5) * weight;
+            weightedY += (y + 0.5) * weight;
+            totalWeight += weight;
+        }
+    }
+    if (totalWeight <= 0) {
+        return { x: sourceWidth / 2, y: sourceHeight / 2 };
+    }
+    return {
+        x: (weightedX / totalWeight / sampleWidth) * sourceWidth,
+        y: (weightedY / totalWeight / sampleHeight) * sourceHeight
+    };
+}
+function findActiveRange(values, minSpan) {
+    const mean = values.reduce((sum, value) => sum + value, 0) / Math.max(values.length, 1);
+    const max = values.reduce((best, value) => Math.max(best, value), 0);
+    if (max <= 0) {
+        return null;
+    }
+    const threshold = mean + (max - mean) * 0.18;
+    let start = 0;
+    while (start < values.length && values[start] < threshold) {
+        start += 1;
+    }
+    let end = values.length - 1;
+    while (end >= 0 && values[end] < threshold) {
+        end -= 1;
+    }
+    if (start >= end) {
+        return null;
+    }
+    const desiredSpan = Math.max(minSpan, end - start + 1);
+    const extra = desiredSpan - (end - start + 1);
+    const expandStart = Math.floor(extra / 2);
+    const expandEnd = extra - expandStart;
+    start = Math.max(0, start - expandStart - 4);
+    end = Math.min(values.length - 1, end + expandEnd + 4);
+    return { start, end };
+}
+function smoothSeries(values, radius) {
+    return values.map((_, index) => {
+        let total = 0;
+        let count = 0;
+        for (let offset = -radius; offset <= radius; offset += 1) {
+            const value = values[index + offset];
+            if (value === undefined) {
+                continue;
+            }
+            total += value;
+            count += 1;
+        }
+        return total / Math.max(count, 1);
+    });
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+async function ensureExactPixelSize(input, target) {
+    const metadata = await sharp(input).metadata();
+    if (metadata.width === target.width && metadata.height === target.height) {
+        return input;
+    }
+    const exactCrop = await cropToPortraitAspect(sharp(input), target.width / target.height);
+    return exactCrop
+        .resize(target.width, target.height, {
+        fit: "cover",
+        position: sharp.strategy.attention
+    })
+        .png()
+        .toBuffer();
+}

package/templates/template_0000/src/remotion/index.js

@@ -0,0 +1,3 @@
+import { registerRoot } from "remotion";
+import { RemotionRoot } from "./Root.js";
+registerRoot(RemotionRoot);

package/templates/template_0000/src/sdk.js

@@ -0,0 +1,3 @@
+export function defineTemplate(definition) {
+    return definition;
+}