@pilio/gemini-watermark-remover 1.0.42 → 1.0.43

package/dist/video-app.js

@@ -1,5 +1,5 @@
 /*!
- * @pilio/gemini-watermark-remover v1.0.42+unknown
+ * @pilio/gemini-watermark-remover v1.0.43+unknown
  * Automatically removes watermarks from Gemini AI generated images
  * (c) 2026 GargantuaX
  * https://github.com/GargantuaX/gemini-watermark-remover

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pilio/gemini-watermark-remover",
   "description": "Automatically removes watermarks from Gemini AI generated images",
-  "version": "1.0.42",
+  "version": "1.0.43",
   "author": "GargantuaX",
   "sideEffects": false,
   "files": [

package/src/core/pipelineCandidateQuality.js

@@ -13,6 +13,7 @@ import {
 } from './previewAlphaCalibration.js';
 import { compareRankingKey } from './watermarkScoring.js';
 import { shouldPreferFullStrengthNewMarginVariant } from './candidateEvaluation.js';
+import { measureRowAlphaEvidence, supportsRowAlphaGain } from './rowAlphaEvidence.js';
 
 export const FINAL_EVIDENCE_WEIGHT = 0.35;
 export const FINAL_RESIDUAL_WEIGHT = 0.40;
@@ -779,7 +780,21 @@ export function rankCompletedCandidates(completed = []) {
     }
     scored.sort(compareRankedCandidates);
     const imperfectionPreferred = applySameAnchor96ImperfectionPreference(scored);
-    const preferred = applyFullStrengthNewMarginPreference(imperfectionPreferred);
+    let preferred = applyFullStrengthNewMarginPreference(imperfectionPreferred);
+    const incumbent = preferred[0];
+    const rowSupported = preferred.find(candidate => {
+        const trial = candidate.hypothesis?.trial;
+        if (candidate === incumbent || !supportsRowAlphaGain(trial?.provenance?.rowAlphaEvidence) ||
+            candidate.result?.meta?.alphaGain !== 0.6 ||
+            !hasSameCandidateAnchor(candidate, incumbent)) return false;
+        const before = measureRowAlphaEvidence(incumbent.result?.imageData, trial.position, trial.alphaMap);
+        const after = measureRowAlphaEvidence(candidate.result?.imageData, trial.position, trial.alphaMap);
+        // Existing cleanup can leave a nonuniform residual. Require positive
+        // evidence in every quadrant, but validate the proposed output's fit.
+        return before?.gain > 0.15 &&
+            before.quadrants.every(value => value > 0.1) && supportsRowAlphaGain(after, 0);
+    });
+    if (rowSupported) preferred = [rowSupported, ...preferred.filter(candidate => candidate !== rowSupported)];
 
     const first = preferred[0];
     const second = preferred[1];

package/src/core/pipelineInitialSelection.js

@@ -15,6 +15,8 @@ import { resolveGeminiWatermarkSearchCatalogEntries } from './geminiSizeCatalog.
 import { measureOutputResidualLocalization } from './outputResidualLocalization.js';
 import { hasReliableStandardWatermarkSignal } from './watermarkPresence.js';
 import { shouldPreferFullStrengthNewMarginVariant } from './candidateEvaluation.js';
+import { measureRowAlphaEvidence, supportsRowAlphaGain } from './rowAlphaEvidence.js';
+import { measurePlaneAlphaEvidence } from './planeAlphaEvidence.js';
 
 const AGGRESSIVE_FALLBACK_MAX_ABS_SPATIAL = 0.22;
 const AGGRESSIVE_FALLBACK_MAX_NEAR_BLACK_INCREASE = 0.05;
@@ -475,6 +477,27 @@ function findCanonical96CatalogPriorTrial({
     };
 }
 
+function createPlaneSourceWitnessTrial(input, fixedSelection, automaticSelection) {
+    const image = input.originalImageData;
+    // Only this exact-size flat-vector cluster has been independently verified.
+    if (image?.width !== 2752 || image.height !== 1536) return null;
+    const position = { x: 2464, y: 1248, width: 96, height: 96 };
+    if ([fixedSelection?.selectedTrial, automaticSelection?.selectedTrial].some(trial =>
+        trial?.accepted === true && trial.position?.width === 96)) return null;
+    const alphaMap = input.alpha96Variants?.['20260520'];
+    const evidence = measurePlaneAlphaEvidence(image, position, alphaMap);
+    if (!evidence) return null;
+    const trial = evaluateRestorationCandidate({
+        originalImageData: image, alphaMap, position, alphaGain: 1,
+        source: 'standard+catalog+plane-source-witness',
+        config: { logoSize: 96, marginRight: 192, marginBottom: 192, alphaVariant: '20260520' },
+        baselineNearBlackRatio: calculateNearBlackRatio(image, position),
+        provenance: { sourceWitnessRescue: true, sourceWitnessReason: 'plane-source-witness', planeSourceEvidence: evidence },
+        includeImageData: false
+    });
+    return measurePresenceLocalization(image, trial).repeatedTemplateCollision ? null : trial;
+}
+
 function selectExact96SourceWitnessTrial({
     r192Trial,
     fixedSelection,
@@ -1080,7 +1103,17 @@ export function collectInitialWatermarkCandidates(input = {}) {
         geometryLockWitness.position.x === input.originalImageData.width - 144 &&
         geometryLockWitness.position.y === input.originalImageData.height - 144 &&
         fixedSelection?.selectedTrial?.position?.width !== 48;
-    let exact48R96SourceWitnessRescueTrial = presenceConfirmed && !possibleV2Collision && !displacedStrongExact48
+    const rowAlphaTrial = [fixedSelection?.selectedTrial, automaticSelection?.selectedTrial]
+        .find(trial => trial?.position?.width === 48 &&
+            trial.position.x === input.originalImageData.width - 144 &&
+            trial.position.y === input.originalImageData.height - 144 &&
+            trial.alphaGain < 0.6 && !trial.config?.alphaVariant &&
+            trial.provenance?.darkPolarity !== true);
+    const rowAlphaEvidence = rowAlphaTrial
+        ? measureRowAlphaEvidence(input.originalImageData, rowAlphaTrial.position, input.alpha48)
+        : null;
+    const supportedRowAlpha = supportsRowAlphaGain(rowAlphaEvidence);
+    let exact48R96SourceWitnessRescueTrial = presenceConfirmed && !possibleV2Collision && !displacedStrongExact48 && !supportedRowAlpha
         ? null
         : createExact48R96SourceWitnessRescueTrial({
             originalImageData: input.originalImageData,
@@ -1088,6 +1121,9 @@ export function collectInitialWatermarkCandidates(input = {}) {
             config: input.config,
             catalogPriorConfig: input.catalogPriorConfig
         });
+    if (supportedRowAlpha && exact48R96SourceWitnessRescueTrial) {
+        exact48R96SourceWitnessRescueTrial.provenance.rowAlphaEvidence = rowAlphaEvidence;
+    }
     if (possibleV2Collision && exact48R96SourceWitnessRescueTrial) {
         if (
             isGeometryCompatibleWithLock(
@@ -1123,7 +1159,8 @@ export function collectInitialWatermarkCandidates(input = {}) {
     });
     const sourceWitnessRescueTrial =
         exact48R96SourceWitnessRescueTrial ??
-        exact96SourceWitnessTrial;
+        exact96SourceWitnessTrial ??
+        createPlaneSourceWitnessTrial(input, fixedSelection, automaticSelection);
     const bestEffortSelections = presenceConfirmed ||
         sourceWitnessRescueTrial
         ? []
@@ -1312,7 +1349,7 @@ export function collectInitialWatermarkCandidates(input = {}) {
             1005
         );
     const hasSupplementalSourceWitness = Boolean(
-        displacedStrongExact48 && sourceWitnessRescueHypothesis
+        (displacedStrongExact48 || supportedRowAlpha || sourceWitnessRescueTrial?.provenance?.planeSourceEvidence) && sourceWitnessRescueHypothesis
     );
     const preferredHypotheses = [
         fixedSelectedHypothesis,

package/src/core/planeAlphaEvidence.js

@@ -0,0 +1,106 @@
+function median(values) {
+    return values.slice().sort((a, b) => a - b)[Math.floor(values.length / 2)];
+}
+
+function solvePlane(matrix, values) {
+    const rows = matrix.map((row, index) => [...row, values[index]]);
+    for (let column = 0; column < 3; column++) {
+        let pivot = column;
+        for (let row = column + 1; row < 3; row++) {
+            if (Math.abs(rows[row][column]) > Math.abs(rows[pivot][column])) pivot = row;
+        }
+        [rows[column], rows[pivot]] = [rows[pivot], rows[column]];
+        if (Math.abs(rows[column][column]) < 1e-10) return null;
+        const divisor = rows[column][column];
+        for (let index = column; index < 4; index++) rows[column][index] /= divisor;
+        for (let row = 0; row < 3; row++) {
+            if (row === column) continue;
+            const factor = rows[row][column];
+            for (let index = column; index < 4; index++) rows[row][index] -= factor * rows[column][index];
+        }
+    }
+    return rows.map(row => row[3]);
+}
+
+// Source-only evidence for the confirmed flat-vector 96px profile. The model
+// never fills pixels: the eventual candidate still performs ordinary inverse alpha.
+export function measurePlaneAlphaEvidence(image, position, alphaMap) {
+    const size = 96;
+    if (!image?.data || alphaMap?.length !== size * size ||
+        position?.width !== size || position.height !== size ||
+        position.x < 32 || position.y < 32 ||
+        position.x + size + 32 > image.width || position.y + size + 32 > image.height) return null;
+    const read = (x, y) => {
+        const offset = ((position.y + y) * image.width + position.x + x) * 4;
+        return [image.data[offset], image.data[offset + 1], image.data[offset + 2]];
+    };
+    const points = [];
+    for (let y = -32; y < size + 32; y += 2) {
+        for (let x = -32; x < size + 32; x += 2) {
+            if (x >= 0 && x < size && y >= 0 && y < size) continue;
+            points.push({ vector: [1, x / size, y / size], rgb: read(x, y) });
+        }
+    }
+    const training = points.filter((_, index) => index % 2 === 0);
+    const validation = points.filter((_, index) => index % 2 === 1);
+    let coefficients = [0, 1, 2].map(channel => [median(training.map(point => point.rgb[channel])), 0, 0]);
+    const predict = vector => coefficients.map(row => row.reduce((sum, value, index) => sum + value * vector[index], 0));
+    const error = point => {
+        const predicted = predict(point.vector);
+        return point.rgb.reduce((sum, value, channel) => sum + Math.abs(value - predicted[channel]), 0) / 3;
+    };
+    for (let iteration = 0; iteration < 8; iteration++) {
+        const errors = training.map(error);
+        const scale = Math.max(2, median(errors) * 2);
+        const matrix = Array.from({ length: 3 }, () => [0, 0, 0]);
+        const values = Array.from({ length: 3 }, () => [0, 0, 0]);
+        for (let index = 0; index < training.length; index++) {
+            const point = training[index];
+            const weight = Math.min(1, scale / Math.max(errors[index], 0.001)) ** 2;
+            for (let row = 0; row < 3; row++) {
+                for (let column = 0; column < 3; column++) matrix[row][column] += weight * point.vector[row] * point.vector[column];
+                for (let channel = 0; channel < 3; channel++) values[channel][row] += weight * point.vector[row] * point.rgb[channel];
+            }
+        }
+        coefficients = values.map(value => solvePlane(matrix, value));
+        if (coefficients.some(row => row === null)) return null;
+    }
+    const backgroundSupport = validation.filter(point => error(point) < 3).length / validation.length;
+    if (backgroundSupport < 0.8) return null;
+    const trials = [];
+    for (let step = 0; step <= 24; step++) {
+        const gain = step * 0.05;
+        let matches = 0;
+        let total = 0;
+        let inlierError = 0;
+        const quadrants = Array.from({ length: 4 }, () => ({ matches: 0, total: 0 }));
+        for (let y = 0; y < size; y++) {
+            for (let x = 0; x < size; x++) {
+                const alpha = alphaMap[y * size + x];
+                if (alpha < 0.1) continue;
+                const background = predict([1, x / size, y / size]);
+                if (Math.max(...background) > 245 || Math.min(...background) < 0) continue;
+                const difference = read(x, y).reduce((sum, value, channel) => sum + Math.abs(
+                    value - ((1 - alpha * gain) * background[channel] + alpha * gain * 255)
+                ), 0) / 3;
+                const quadrant = quadrants[(y >= size / 2 ? 2 : 0) + (x >= size / 2 ? 1 : 0)];
+                total++;
+                quadrant.total++;
+                if (difference < 3) {
+                    matches++;
+                    quadrant.matches++;
+                    inlierError += difference;
+                }
+            }
+        }
+        trials.push({ gain, fraction: matches / total, error: matches ? inlierError / matches : Infinity,
+            quadrants: quadrants.map(quadrant => quadrant.matches / quadrant.total) });
+    }
+    trials.sort((left, right) => right.fraction - left.fraction || left.error - right.error);
+    const best = trials[0];
+    const zero = trials.find(trial => trial.gain === 0);
+    if (best.gain !== 1 || best.fraction < 0.55 || zero.fraction >= 0.1 ||
+        !best.quadrants.every(fraction => fraction >= 0.3)) return null;
+    return { backgroundSupport, gain: best.gain, matchFraction: best.fraction,
+        quadrantSupport: best.quadrants, zeroGainSupport: zero.fraction };
+}

package/src/core/rowAlphaEvidence.js

@@ -0,0 +1,59 @@
+// Estimate a white watermark's gain from neighboring source pixels. This is
+// evidence for inverse-alpha candidates only; never synthesize replacement rows.
+function quantile(values, fraction) {
+    if (values.length === 0) return NaN;
+    const sorted = values.slice().sort((a, b) => a - b);
+    return sorted[Math.floor((sorted.length - 1) * fraction)];
+}
+
+export function measureRowAlphaEvidence(image, position, alphaMap) {
+    if (!image?.data || !position || position.width !== 48 || position.height !== 48 ||
+        alphaMap?.length !== 48 * 48 || position.x < 20 || position.y < 0 ||
+        position.x + 68 > image.width || position.y + 48 > image.height) return null;
+    const gains = [];
+    const quadrants = [[], [], [], []];
+    const points = [];
+    let outsideError = 0;
+    let outsideCount = 0;
+    for (let row = 0; row < 48; row++) {
+        for (let channel = 0; channel < 3; channel++) {
+            const value = column => image.data[
+                ((position.y + row) * image.width + position.x + column) * 4 + channel
+            ];
+            const left = quantile(Array.from({ length: 12 }, (_, i) => value(-20 + i)), 0.5);
+            const right = quantile(Array.from({ length: 12 }, (_, i) => value(56 + i)), 0.5);
+            const background = column => left + (right - left) * (column + 14.5) / 76;
+            for (const column of [-8, -6, -4, -2, 48, 50, 52, 54]) {
+                outsideError += Math.abs(value(column) - background(column));
+                outsideCount++;
+            }
+            for (let column = 0; column < 48; column++) {
+                const alpha = alphaMap[row * 48 + column];
+                const reference = background(column);
+                if (alpha < 0.05 || reference > 220) continue;
+                const observed = value(column);
+                const gain = (observed - reference) / ((255 - reference) * alpha);
+                gains.push(gain);
+                quadrants[(row >= 24 ? 2 : 0) + (column >= 24 ? 1 : 0)].push(gain);
+                points.push({ observed, reference, alpha });
+            }
+        }
+    }
+    if (quadrants.some(values => values.length < 24)) return null;
+    const gain = quantile(gains, 0.5);
+    return {
+        gain,
+        spread: quantile(gains, 0.75) - quantile(gains, 0.25),
+        quadrants: quadrants.map(values => quantile(values, 0.5)),
+        outsideError: outsideError / outsideCount,
+        fitError: points.reduce((sum, point) => sum + Math.abs(
+            point.observed - point.reference - (255 - point.reference) * point.alpha * gain
+        ), 0) / points.length
+    };
+}
+
+export function supportsRowAlphaGain(evidence, gain = 0.6) {
+    return evidence != null && Math.abs(evidence.gain - gain) <= 0.05 &&
+        evidence.spread <= 0.08 && evidence.outsideError <= 4 && evidence.fitError <= 3 &&
+        evidence.quadrants.every(value => Math.abs(value - gain) <= 0.08);
+}