@pilio/gemini-watermark-remover 1.0.20 → 1.0.21

package/src/core/allenkFdncnnReferenceRuntime.js

@@ -0,0 +1,169 @@
+import {
+    buildAllenkFdncnnInput,
+    convertAllenkFdncnnOutputToRgba
+} from './allenkFdncnnDenoise.js';
+import { halfToFloat } from './allenkFdncnnNcnnModel.js';
+
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+
+function readUInt16LE(bytes, offset) {
+    return bytes[offset] | (bytes[offset + 1] << 8);
+}
+
+function readFloat32LE(bytes, offset) {
+    return new DataView(bytes.buffer, bytes.byteOffset + offset, 4).getFloat32(0, true);
+}
+
+function calculateSegmentMacs(segment, width, height) {
+    return width * height *
+        segment.outputChannels *
+        segment.inputChannels *
+        segment.kernelW *
+        segment.kernelH;
+}
+
+function calculateLayoutMacs(segments, width, height) {
+    return segments.reduce((sum, segment) => sum + calculateSegmentMacs(segment, width, height), 0);
+}
+
+function decodeSegmentWeights(segment, weightBin) {
+    const weights = new Float32Array(segment.weightCount);
+    for (let i = 0; i < segment.weightCount; i++) {
+        weights[i] = halfToFloat(readUInt16LE(weightBin, segment.weightOffset + i * 2));
+    }
+
+    const bias = new Float32Array(segment.biasCount);
+    for (let i = 0; i < segment.biasCount; i++) {
+        bias[i] = readFloat32LE(weightBin, segment.biasOffset + i * 4);
+    }
+
+    return { weights, bias };
+}
+
+function runSamePaddingConvolution({
+    input,
+    width,
+    height,
+    segment,
+    weights,
+    bias
+}) {
+    const outputChannels = segment.outputChannels;
+    const inputChannels = segment.inputChannels;
+    const output = new Float32Array(width * height * outputChannels);
+    const kernelW = segment.kernelW;
+    const kernelH = segment.kernelH;
+    const padX = segment.padW;
+    const padY = segment.padH;
+    const relu = segment.activationType === 1;
+    const plane = width * height;
+
+    for (let oc = 0; oc < outputChannels; oc++) {
+        const outputBase = oc * plane;
+        const biasValue = bias[oc] || 0;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                let sum = biasValue;
+                for (let ic = 0; ic < inputChannels; ic++) {
+                    const inputBase = ic * plane;
+                    const weightBase = (((oc * inputChannels) + ic) * kernelH) * kernelW;
+                    for (let ky = 0; ky < kernelH; ky++) {
+                        const sy = y + ky - padY;
+                        if (sy < 0 || sy >= height) continue;
+                        for (let kx = 0; kx < kernelW; kx++) {
+                            const sx = x + kx - padX;
+                            if (sx < 0 || sx >= width) continue;
+                            sum += input[inputBase + sy * width + sx] * weights[weightBase + ky * kernelW + kx];
+                        }
+                    }
+                }
+                output[outputBase + y * width + x] = relu ? Math.max(0, sum) : sum;
+            }
+        }
+    }
+
+    return output;
+}
+
+function createAllenkFdncnnReferenceRuntime({
+    weightBin,
+    weightLayout,
+    maxMacs = 50_000_000
+} = {}) {
+    if (!weightBin || !weightLayout?.segments?.length) {
+        throw new Error('Missing allenk FDnCNN weight bin or layout');
+    }
+
+    const bin = weightBin instanceof Uint8Array ? weightBin : new Uint8Array(weightBin);
+    const decodedSegments = weightLayout.segments.map((segment) => ({
+        segment,
+        ...decodeSegmentWeights(segment, bin)
+    }));
+
+    return {
+        id: 'allenk-fdncnn-pure-js-reference',
+        status: 'debug-only',
+        maxMacs,
+        estimateMacs(width, height) {
+            return calculateLayoutMacs(weightLayout.segments, width, height);
+        },
+        execute(input, width, height) {
+            const macs = calculateLayoutMacs(weightLayout.segments, width, height);
+            if (macs > maxMacs) {
+                const error = new Error(`allenk FDnCNN pure JS reference refused ${macs} MACs; max=${maxMacs}`);
+                error.code = 'ALLENK_FDNCNN_REFERENCE_MAC_LIMIT';
+                error.macs = macs;
+                error.maxMacs = maxMacs;
+                throw error;
+            }
+
+            let current = input;
+            for (const decoded of decodedSegments) {
+                current = runSamePaddingConvolution({
+                    input: current,
+                    width,
+                    height,
+                    segment: decoded.segment,
+                    weights: decoded.weights,
+                    bias: decoded.bias
+                });
+            }
+
+            for (let i = 0; i < current.length; i++) {
+                current[i] = clamp(current[i], 0, 1);
+            }
+
+            return {
+                output: current,
+                macs,
+                runtime: this.id
+            };
+        },
+        denoiseImageData({ imageData, sigma } = {}) {
+            const input = buildAllenkFdncnnInput({ imageData, sigma });
+            const result = this.execute(input, imageData.width, imageData.height);
+            return {
+                ...result,
+                imageData: {
+                    width: imageData.width,
+                    height: imageData.height,
+                    data: convertAllenkFdncnnOutputToRgba({
+                        output: result.output,
+                        width: imageData.width,
+                        height: imageData.height
+                    })
+                }
+            };
+        }
+    };
+}
+
+export {
+    calculateLayoutMacs,
+    calculateSegmentMacs,
+    createAllenkFdncnnReferenceRuntime,
+    decodeSegmentWeights,
+    runSamePaddingConvolution
+};

package/src/core/alphaGradientMask.js

@@ -0,0 +1,165 @@
+const EPSILON = 1e-8;
+
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+
+function gaussianKernel1D(sigma) {
+    if (!Number.isFinite(sigma) || sigma <= 0) return null;
+
+    const radius = Math.max(1, Math.ceil(sigma * 3));
+    const kernel = new Float32Array(radius * 2 + 1);
+    let sum = 0;
+
+    for (let i = -radius; i <= radius; i++) {
+        const value = Math.exp(-(i * i) / (2 * sigma * sigma));
+        kernel[i + radius] = value;
+        sum += value;
+    }
+
+    if (sum <= EPSILON) return null;
+
+    for (let i = 0; i < kernel.length; i++) {
+        kernel[i] /= sum;
+    }
+
+    return { kernel, radius };
+}
+
+function blurHorizontal(values, width, height, kernelInfo) {
+    const out = new Float32Array(values.length);
+    const { kernel, radius } = kernelInfo;
+
+    for (let y = 0; y < height; y++) {
+        const rowBase = y * width;
+        for (let x = 0; x < width; x++) {
+            let sum = 0;
+            for (let k = -radius; k <= radius; k++) {
+                const sx = clamp(x + k, 0, width - 1);
+                sum += values[rowBase + sx] * kernel[k + radius];
+            }
+            out[rowBase + x] = sum;
+        }
+    }
+
+    return out;
+}
+
+function blurVertical(values, width, height, kernelInfo) {
+    const out = new Float32Array(values.length);
+    const { kernel, radius } = kernelInfo;
+
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let sum = 0;
+            for (let k = -radius; k <= radius; k++) {
+                const sy = clamp(y + k, 0, height - 1);
+                sum += values[sy * width + x] * kernel[k + radius];
+            }
+            out[y * width + x] = sum;
+        }
+    }
+
+    return out;
+}
+
+function gaussianBlur(values, width, height, sigma) {
+    const kernelInfo = gaussianKernel1D(sigma);
+    if (!kernelInfo) return new Float32Array(values);
+
+    return blurVertical(
+        blurHorizontal(values, width, height, kernelInfo),
+        width,
+        height,
+        kernelInfo
+    );
+}
+
+function dilate(values, width, height, radius) {
+    if (!Number.isFinite(radius) || radius <= 0) return new Float32Array(values);
+
+    const roundedRadius = Math.max(1, Math.round(radius));
+    const radiusSquared = roundedRadius * roundedRadius;
+    const out = new Float32Array(values.length);
+
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let maxValue = 0;
+            for (let dy = -roundedRadius; dy <= roundedRadius; dy++) {
+                for (let dx = -roundedRadius; dx <= roundedRadius; dx++) {
+                    if (dx * dx + dy * dy > radiusSquared) continue;
+                    const sx = x + dx;
+                    const sy = y + dy;
+                    if (sx < 0 || sy < 0 || sx >= width || sy >= height) continue;
+                    maxValue = Math.max(maxValue, values[sy * width + sx]);
+                }
+            }
+            out[y * width + x] = maxValue;
+        }
+    }
+
+    return out;
+}
+
+export function createAlphaGradientMask({
+    alphaMap,
+    width,
+    height = width,
+    strength = 1,
+    gamma = 0.5,
+    dilateRadius = 2,
+    blurSigma = 2
+}) {
+    if (!alphaMap || width <= 0 || height <= 0 || alphaMap.length < width * height) {
+        return new Float32Array(0);
+    }
+
+    const gradient = new Float32Array(width * height);
+    let minGradient = Number.POSITIVE_INFINITY;
+    let maxGradient = 0;
+
+    for (let y = 1; y < height - 1; y++) {
+        for (let x = 1; x < width - 1; x++) {
+            const i = y * width + x;
+            const gx =
+                -alphaMap[i - width - 1] - 2 * alphaMap[i - 1] - alphaMap[i + width - 1] +
+                alphaMap[i - width + 1] + 2 * alphaMap[i + 1] + alphaMap[i + width + 1];
+            const gy =
+                -alphaMap[i - width - 1] - 2 * alphaMap[i - width] - alphaMap[i - width + 1] +
+                alphaMap[i + width - 1] + 2 * alphaMap[i + width] + alphaMap[i + width + 1];
+            const value = Math.sqrt(gx * gx + gy * gy);
+            gradient[i] = value;
+            minGradient = Math.min(minGradient, value);
+            maxGradient = Math.max(maxGradient, value);
+        }
+    }
+
+    if (!Number.isFinite(minGradient) || maxGradient <= minGradient + EPSILON) {
+        return new Float32Array(width * height);
+    }
+
+    const normalized = new Float32Array(width * height);
+    const exponent = Number.isFinite(gamma) && gamma > 0 ? gamma : 1;
+    for (let i = 0; i < normalized.length; i++) {
+        const value = (gradient[i] - minGradient) / (maxGradient - minGradient);
+        normalized[i] = Math.pow(clamp(value, 0, 1), exponent);
+    }
+
+    const expanded = dilate(normalized, width, height, dilateRadius);
+    const blurred = gaussianBlur(expanded, width, height, blurSigma);
+    const safeStrength = Number.isFinite(strength) ? Math.max(0, strength) : 1;
+
+    for (let i = 0; i < blurred.length; i++) {
+        blurred[i] = clamp(blurred[i] * safeStrength, 0, 1);
+    }
+
+    return blurred;
+}
+
+export function getAlphaGradientWeight(mask, index, floor = 0.35) {
+    if (!mask || index < 0 || index >= mask.length) {
+        return clamp(floor, 0, 1);
+    }
+
+    return Math.max(clamp(floor, 0, 1), clamp(mask[index], 0, 1));
+}

package/src/core/blendModes.js

@@ -37,11 +37,16 @@ export function removeWatermark(imageData, alphaMap, position, options = {}) {
             // Calculate index in alpha map
             const alphaIdx = row * width + col;
 
-            // Get alpha value
+            // Get alpha value. A negative alpha map marks a dark-polarity
+            // watermark: same opacity mask, black logo value.
             const rawAlpha = alphaMap[alphaIdx];
+            const alphaMagnitude = Math.abs(rawAlpha);
+            const logoValue = Number.isFinite(options.logoValue)
+                ? options.logoValue
+                : (rawAlpha < 0 ? 0 : LOGO_VALUE);
 
             // Remove low-level alpha noise from compressed background capture.
-            const signalAlpha = Math.max(0, rawAlpha - ALPHA_NOISE_FLOOR) * alphaGain;
+            const signalAlpha = Math.max(0, alphaMagnitude - ALPHA_NOISE_FLOOR) * alphaGain;
 
             // Skip very small alpha values (noise)
             if (signalAlpha < ALPHA_THRESHOLD) {
@@ -49,7 +54,7 @@ export function removeWatermark(imageData, alphaMap, position, options = {}) {
             }
 
             // Use original alpha for inverse solve; use denoised alpha as activation signal.
-            const alpha = Math.min(rawAlpha * alphaGain, MAX_ALPHA);
+            const alpha = Math.min(alphaMagnitude * alphaGain, MAX_ALPHA);
             const oneMinusAlpha = 1.0 - alpha;
 
             // Apply reverse alpha blending to each RGB channel
@@ -57,7 +62,7 @@ export function removeWatermark(imageData, alphaMap, position, options = {}) {
                 const watermarked = imageData.data[imgIdx + c];
 
                 // Reverse alpha blending formula
-                const original = (watermarked - alpha * LOGO_VALUE) / oneMinusAlpha;
+                const original = (watermarked - alpha * logoValue) / oneMinusAlpha;
 
                 // Clip to [0, 255] range
                 imageData.data[imgIdx + c] = Math.max(0, Math.min(255, Math.round(original)));