@pilio/gemini-watermark-remover 1.0.19 → 1.0.21

package/src/core/allenkFdncnnDenoise.js

@@ -0,0 +1,326 @@
+import { createAlphaGradientMask } from './alphaGradientMask.js';
+
+const ALLENK_FDNCNN_MODEL = Object.freeze({
+    name: 'FDnCNN Color FP16',
+    upstream: 'allenk/GeminiWatermarkTool',
+    license: 'MIT',
+    runtime: 'NCNN',
+    inputBlob: 0,
+    outputBlob: 20,
+    inputLayout: '[R, G, B, sigma] CHW float32',
+    outputLayout: '[R, G, B] CHW float32',
+    defaultSigma: 25,
+    defaultStrength: 0.85,
+    defaultPadding: 16,
+    maxSigma: 150,
+    maxStrength: 3
+});
+
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+
+function createGaussianKernel(sigma, radius = Math.ceil(sigma * 3)) {
+    const safeSigma = Math.max(0.01, sigma);
+    const safeRadius = Math.max(1, Math.round(radius));
+    const kernel = new Float32Array(safeRadius * 2 + 1);
+    let sum = 0;
+
+    for (let i = -safeRadius; i <= safeRadius; i++) {
+        const value = Math.exp(-(i * i) / (2 * safeSigma * safeSigma));
+        kernel[i + safeRadius] = value;
+        sum += value;
+    }
+
+    for (let i = 0; i < kernel.length; i++) {
+        kernel[i] /= sum;
+    }
+
+    return { kernel, radius: safeRadius };
+}
+
+function gaussianBlurFloatMap(source, width, height, sigma, radius = Math.ceil(sigma * 3)) {
+    if (!source || width <= 0 || height <= 0 || !Number.isFinite(sigma) || sigma <= 0) {
+        return new Float32Array(source || 0);
+    }
+
+    const { kernel, radius: r } = createGaussianKernel(sigma, radius);
+    const temp = new Float32Array(source.length);
+    const output = new Float32Array(source.length);
+
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let sum = 0;
+            for (let dx = -r; dx <= r; dx++) {
+                const xx = clamp(x + dx, 0, width - 1);
+                sum += source[y * width + xx] * kernel[dx + r];
+            }
+            temp[y * width + x] = sum;
+        }
+    }
+
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let sum = 0;
+            for (let dy = -r; dy <= r; dy++) {
+                const yy = clamp(y + dy, 0, height - 1);
+                sum += temp[yy * width + x] * kernel[dy + r];
+            }
+            output[y * width + x] = sum;
+        }
+    }
+
+    return output;
+}
+
+function inferSquareSize(alphaMap) {
+    const size = Math.round(Math.sqrt(alphaMap?.length || 0));
+    return size > 0 && size * size === alphaMap.length ? size : 0;
+}
+
+function resizeSquareAlphaMapArea(sourceAlpha, sourceSize, targetWidth, targetHeight = targetWidth) {
+    if (!sourceAlpha || sourceSize <= 0 || targetWidth <= 0 || targetHeight <= 0) {
+        return new Float32Array(0);
+    }
+    if (sourceSize === targetWidth && sourceSize === targetHeight) {
+        return new Float32Array(sourceAlpha);
+    }
+
+    const output = new Float32Array(targetWidth * targetHeight);
+    const scaleX = sourceSize / targetWidth;
+    const scaleY = sourceSize / targetHeight;
+
+    for (let y = 0; y < targetHeight; y++) {
+        const yStart = y * scaleY;
+        const yEnd = (y + 1) * scaleY;
+        const y0 = Math.floor(yStart);
+        const y1 = Math.ceil(yEnd);
+
+        for (let x = 0; x < targetWidth; x++) {
+            const xStart = x * scaleX;
+            const xEnd = (x + 1) * scaleX;
+            const x0 = Math.floor(xStart);
+            const x1 = Math.ceil(xEnd);
+
+            let sum = 0;
+            let areaSum = 0;
+            for (let sy = y0; sy < y1; sy++) {
+                if (sy < 0 || sy >= sourceSize) continue;
+                const wy = Math.max(0, Math.min(yEnd, sy + 1) - Math.max(yStart, sy));
+                for (let sx = x0; sx < x1; sx++) {
+                    if (sx < 0 || sx >= sourceSize) continue;
+                    const wx = Math.max(0, Math.min(xEnd, sx + 1) - Math.max(xStart, sx));
+                    const area = wx * wy;
+                    sum += sourceAlpha[sy * sourceSize + sx] * area;
+                    areaSum += area;
+                }
+            }
+
+            output[y * targetWidth + x] = areaSum > 0 ? sum / areaSum : 0;
+        }
+    }
+
+    return output;
+}
+
+function normalizeAllenkFdncnnOptions(options = {}) {
+    const sigma = Number.isFinite(options.sigma)
+        ? clamp(options.sigma, 0, ALLENK_FDNCNN_MODEL.maxSigma)
+        : ALLENK_FDNCNN_MODEL.defaultSigma;
+    const strength = Number.isFinite(options.strength)
+        ? clamp(options.strength, 0, ALLENK_FDNCNN_MODEL.maxStrength)
+        : ALLENK_FDNCNN_MODEL.defaultStrength;
+    const padding = Number.isFinite(options.padding)
+        ? Math.max(0, Math.round(options.padding))
+        : ALLENK_FDNCNN_MODEL.defaultPadding;
+
+    return { sigma, strength, padding };
+}
+
+function createAllenkGradientMask({
+    alphaMap,
+    width,
+    height = width,
+    strength = ALLENK_FDNCNN_MODEL.defaultStrength
+} = {}) {
+    const sourceSize = inferSquareSize(alphaMap);
+    const resizedAlphaMap = sourceSize > 0
+        ? resizeSquareAlphaMapArea(alphaMap, sourceSize, width, height)
+        : alphaMap;
+
+    return createAlphaGradientMask({
+        alphaMap: resizedAlphaMap,
+        width,
+        height,
+        strength,
+        gamma: 0.5,
+        dilateRadius: 2,
+        blurSigma: 2
+    });
+}
+
+function calculateAllenkPaddedRoi({ imageWidth, imageHeight, region, padding = ALLENK_FDNCNN_MODEL.defaultPadding } = {}) {
+    if (!region || imageWidth <= 0 || imageHeight <= 0 || region.width <= 0 || region.height <= 0) {
+        return null;
+    }
+
+    const safePadding = Math.max(0, Math.round(padding));
+    const x = clamp(Math.round(region.x - safePadding), 0, imageWidth);
+    const y = clamp(Math.round(region.y - safePadding), 0, imageHeight);
+    const right = clamp(Math.round(region.x + region.width + safePadding), 0, imageWidth);
+    const bottom = clamp(Math.round(region.y + region.height + safePadding), 0, imageHeight);
+    const width = right - x;
+    const height = bottom - y;
+
+    if (width < 4 || height < 4) return null;
+
+    return {
+        x,
+        y,
+        width,
+        height,
+        inner: {
+            x: clamp(Math.round(region.x - x), 0, width),
+            y: clamp(Math.round(region.y - y), 0, height),
+            width: clamp(Math.round(region.width), 0, width),
+            height: clamp(Math.round(region.height), 0, height)
+        }
+    };
+}
+
+function embedAllenkRoiWeights({ roiWeights, roiWidth, roiHeight, paddedRoi, blurSigma = 1 } = {}) {
+    if (!roiWeights || !paddedRoi?.inner || roiWidth <= 0 || roiHeight <= 0) {
+        return new Float32Array(0);
+    }
+
+    const weights = new Float32Array(paddedRoi.width * paddedRoi.height);
+    const inner = paddedRoi.inner;
+
+    for (let y = 0; y < roiHeight; y++) {
+        const py = inner.y + y;
+        if (py < 0 || py >= paddedRoi.height) continue;
+
+        for (let x = 0; x < roiWidth; x++) {
+            const px = inner.x + x;
+            if (px < 0 || px >= paddedRoi.width) continue;
+            weights[py * paddedRoi.width + px] = clamp(roiWeights[y * roiWidth + x] || 0, 0, 1);
+        }
+    }
+
+    return gaussianBlurFloatMap(weights, paddedRoi.width, paddedRoi.height, blurSigma);
+}
+
+function buildAllenkFdncnnInput({ imageData, sigma = ALLENK_FDNCNN_MODEL.defaultSigma } = {}) {
+    if (!imageData?.data || imageData.width <= 0 || imageData.height <= 0) {
+        return new Float32Array(0);
+    }
+
+    const { width, height, data } = imageData;
+    const pixelCount = width * height;
+    const input = new Float32Array(pixelCount * 4);
+    const sigmaNorm = clamp(sigma, 0, ALLENK_FDNCNN_MODEL.maxSigma) / 255;
+    const stride = data.length >= pixelCount * 4 ? 4 : 3;
+
+    for (let i = 0; i < pixelCount; i++) {
+        const src = i * stride;
+        input[i] = (data[src] || 0) / 255;
+        input[pixelCount + i] = (data[src + 1] || 0) / 255;
+        input[pixelCount * 2 + i] = (data[src + 2] || 0) / 255;
+        input[pixelCount * 3 + i] = sigmaNorm;
+    }
+
+    return input;
+}
+
+function convertAllenkFdncnnOutputToRgba({ output, width, height, alpha = 255 } = {}) {
+    if (!output || width <= 0 || height <= 0) {
+        return new Uint8ClampedArray(0);
+    }
+
+    const pixelCount = width * height;
+    const rgba = new Uint8ClampedArray(pixelCount * 4);
+
+    for (let i = 0; i < pixelCount; i++) {
+        rgba[i * 4] = Math.round(clamp(output[i] || 0, 0, 1) * 255);
+        rgba[i * 4 + 1] = Math.round(clamp(output[pixelCount + i] || 0, 0, 1) * 255);
+        rgba[i * 4 + 2] = Math.round(clamp(output[pixelCount * 2 + i] || 0, 0, 1) * 255);
+        rgba[i * 4 + 3] = alpha;
+    }
+
+    return rgba;
+}
+
+function getLocalMeanRgb(data, width, height, x, y, channel) {
+    let sum = 0;
+    let count = 0;
+    for (let dy = -1; dy <= 1; dy++) {
+        const yy = y + dy;
+        if (yy < 0 || yy >= height) continue;
+        for (let dx = -1; dx <= 1; dx++) {
+            const xx = x + dx;
+            if (xx < 0 || xx >= width) continue;
+            sum += data[(yy * width + xx) * 4 + channel];
+            count++;
+        }
+    }
+    return count > 0 ? sum / count : data[(y * width + x) * 4 + channel];
+}
+
+function blendAllenkDenoisedRoi({
+    originalData,
+    denoisedData,
+    weights,
+    width = 0,
+    height = 0,
+    preserveHighpassStrength = 0
+} = {}) {
+    if (!originalData || !denoisedData || !weights || originalData.length !== denoisedData.length) {
+        return new Uint8ClampedArray(originalData || 0);
+    }
+
+    const output = new Uint8ClampedArray(originalData);
+    const pixelCount = Math.min(weights.length, Math.floor(originalData.length / 4));
+    const canPreserveHighpass = (
+        Number.isFinite(preserveHighpassStrength) &&
+        preserveHighpassStrength > 0 &&
+        Number.isFinite(width) &&
+        Number.isFinite(height) &&
+        width > 0 &&
+        height > 0 &&
+        width * height <= pixelCount
+    );
+
+    for (let pixel = 0; pixel < pixelCount; pixel++) {
+        const weight = clamp(weights[pixel] || 0, 0, 1);
+        if (weight <= 0) continue;
+
+        const idx = pixel * 4;
+        const x = canPreserveHighpass ? pixel % width : 0;
+        const y = canPreserveHighpass ? Math.floor(pixel / width) : 0;
+        const highpassGain = canPreserveHighpass
+            ? Math.min(0.28, weight * preserveHighpassStrength)
+            : 0;
+        for (let c = 0; c < 3; c++) {
+            const blended = (
+                originalData[idx + c] * (1 - weight) + denoisedData[idx + c] * weight
+            );
+            const highpass = highpassGain > 0
+                ? clamp(originalData[idx + c] - getLocalMeanRgb(originalData, width, height, x, y, c), -14, 14)
+                : 0;
+            output[idx + c] = Math.round(clamp(blended + highpass * highpassGain, 0, 255));
+        }
+    }
+
+    return output;
+}
+
+export {
+    ALLENK_FDNCNN_MODEL,
+    blendAllenkDenoisedRoi,
+    buildAllenkFdncnnInput,
+    calculateAllenkPaddedRoi,
+    convertAllenkFdncnnOutputToRgba,
+    createAllenkGradientMask,
+    embedAllenkRoiWeights,
+    normalizeAllenkFdncnnOptions
+};

package/src/core/allenkFdncnnNcnnModel.js

@@ -0,0 +1,244 @@
+const NCNN_BINARY_PARAM_MAGIC = 7767517;
+const NCNN_LAYER_TYPES = Object.freeze({
+    6: 'Convolution',
+    16: 'Input'
+});
+const NCNN_WEIGHT_FP16_STORAGE_TAG = 0x01306b47;
+
+function readInt32LE(buffer, offset) {
+    if (offset + 4 > buffer.length) {
+        throw new Error(`Unexpected end of NCNN param at byte ${offset}`);
+    }
+    return buffer.readInt32LE
+        ? buffer.readInt32LE(offset)
+        : new DataView(buffer.buffer, buffer.byteOffset + offset, 4).getInt32(0, true);
+}
+
+function readUInt32LE(buffer, offset) {
+    if (offset + 4 > buffer.length) {
+        throw new Error(`Unexpected end of NCNN bin at byte ${offset}`);
+    }
+    return buffer.readUInt32LE
+        ? buffer.readUInt32LE(offset)
+        : new DataView(buffer.buffer, buffer.byteOffset + offset, 4).getUint32(0, true);
+}
+
+function normalizeBuffer(buffer) {
+    if (buffer instanceof Uint8Array) return buffer;
+    return new Uint8Array(buffer);
+}
+
+function parseParamPairs(buffer, cursor) {
+    const params = {};
+    let offset = cursor;
+
+    while (offset < buffer.length) {
+        const key = readInt32LE(buffer, offset);
+        offset += 4;
+        if (key === -233) {
+            return { params, offset };
+        }
+
+        const value = readInt32LE(buffer, offset);
+        offset += 4;
+        params[key] = value;
+    }
+
+    throw new Error('NCNN layer params were not terminated by -233');
+}
+
+function getNcnnLayerTypeName(typeIndex) {
+    return NCNN_LAYER_TYPES[typeIndex] || `LayerType${typeIndex}`;
+}
+
+function normalizeConvolutionParams(params = {}) {
+    return {
+        numOutput: params[0] ?? 0,
+        kernelW: params[1] ?? 0,
+        dilationW: params[2] ?? 1,
+        strideW: params[3] ?? 1,
+        padW: params[4] ?? 0,
+        biasTerm: params[5] ?? 0,
+        weightDataSize: params[6] ?? 0,
+        activationType: params[9] ?? 0,
+        kernelH: params[11] ?? params[1] ?? 0,
+        dilationH: params[12] ?? params[2] ?? 1,
+        strideH: params[13] ?? params[3] ?? 1,
+        padH: params[14] ?? params[4] ?? 0
+    };
+}
+
+function parseAllenkFdncnnParam(bufferLike) {
+    const buffer = normalizeBuffer(bufferLike);
+    let offset = 0;
+
+    const magic = readInt32LE(buffer, offset);
+    offset += 4;
+    if (magic !== NCNN_BINARY_PARAM_MAGIC) {
+        throw new Error(`Unsupported NCNN binary param magic: ${magic}`);
+    }
+
+    const layerCount = readInt32LE(buffer, offset);
+    offset += 4;
+    const blobCount = readInt32LE(buffer, offset);
+    offset += 4;
+    const layers = [];
+
+    for (let i = 0; i < layerCount; i++) {
+        const typeIndex = readInt32LE(buffer, offset);
+        offset += 4;
+        const bottomCount = readInt32LE(buffer, offset);
+        offset += 4;
+        const topCount = readInt32LE(buffer, offset);
+        offset += 4;
+        const bottoms = [];
+        const tops = [];
+
+        for (let b = 0; b < bottomCount; b++) {
+            bottoms.push(readInt32LE(buffer, offset));
+            offset += 4;
+        }
+        for (let t = 0; t < topCount; t++) {
+            tops.push(readInt32LE(buffer, offset));
+            offset += 4;
+        }
+
+        const parsed = parseParamPairs(buffer, offset);
+        offset = parsed.offset;
+
+        const type = getNcnnLayerTypeName(typeIndex);
+        const layer = {
+            index: i,
+            typeIndex,
+            type,
+            bottoms,
+            tops,
+            params: parsed.params
+        };
+        if (type === 'Convolution') {
+            layer.convolution = normalizeConvolutionParams(parsed.params);
+        }
+        layers.push(layer);
+    }
+
+    return {
+        magic,
+        layerCount,
+        blobCount,
+        layers,
+        bytesRead: offset,
+        byteLength: buffer.length
+    };
+}
+
+function halfToFloat(half) {
+    const sign = (half & 0x8000) ? -1 : 1;
+    const exponent = (half >> 10) & 0x1f;
+    const fraction = half & 0x03ff;
+
+    if (exponent === 0) {
+        return sign * Math.pow(2, -14) * (fraction / 1024);
+    }
+    if (exponent === 0x1f) {
+        return fraction ? Number.NaN : sign * Number.POSITIVE_INFINITY;
+    }
+    return sign * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
+}
+
+function buildAllenkFdncnnWeightLayout(param, binLike) {
+    const bin = normalizeBuffer(binLike);
+    let offset = 0;
+    let inputChannels = 4;
+    const segments = [];
+
+    for (const layer of param.layers) {
+        if (layer.type !== 'Convolution') {
+            continue;
+        }
+
+        const conv = layer.convolution;
+        const expectedWeightCount = conv.numOutput * inputChannels * conv.kernelW * conv.kernelH;
+        if (expectedWeightCount !== conv.weightDataSize) {
+            throw new Error(
+                `Unexpected weight count for layer ${layer.index}: expected ${expectedWeightCount}, got ${conv.weightDataSize}`
+            );
+        }
+
+        const storageTag = readUInt32LE(bin, offset);
+        if (storageTag !== NCNN_WEIGHT_FP16_STORAGE_TAG) {
+            throw new Error(`Unexpected NCNN weight storage tag at layer ${layer.index}: 0x${storageTag.toString(16)}`);
+        }
+        const weightOffset = offset + 4;
+        const weightBytes = conv.weightDataSize * 2;
+        const biasOffset = weightOffset + weightBytes;
+        const biasCount = conv.biasTerm ? conv.numOutput : 0;
+        const biasBytes = biasCount * 4;
+
+        if (biasOffset + biasBytes > bin.length) {
+            throw new Error(`NCNN weights exceed bin length at layer ${layer.index}`);
+        }
+
+        segments.push({
+            layerIndex: layer.index,
+            type: layer.type,
+            inputChannels,
+            outputChannels: conv.numOutput,
+            kernelW: conv.kernelW,
+            kernelH: conv.kernelH,
+            strideW: conv.strideW,
+            strideH: conv.strideH,
+            padW: conv.padW,
+            padH: conv.padH,
+            activationType: conv.activationType,
+            storageTag,
+            weightOffset,
+            weightBytes,
+            weightCount: conv.weightDataSize,
+            biasOffset,
+            biasBytes,
+            biasCount
+        });
+
+        offset = biasOffset + biasBytes;
+        inputChannels = conv.numOutput;
+    }
+
+    return {
+        storage: 'fp16-weights-fp32-bias',
+        byteLength: bin.length,
+        bytesRead: offset,
+        segments
+    };
+}
+
+function summarizeAllenkFdncnnModel(param, weightLayout = null) {
+    const convolutionLayers = param.layers.filter((layer) => layer.type === 'Convolution');
+    const reluLayers = convolutionLayers.filter((layer) => layer.convolution?.activationType === 1);
+    const outputLayer = convolutionLayers[convolutionLayers.length - 1] || null;
+
+    return {
+        layerCount: param.layerCount,
+        blobCount: param.blobCount,
+        convolutionLayerCount: convolutionLayers.length,
+        reluConvolutionLayerCount: reluLayers.length,
+        inputBlob: 0,
+        outputBlob: outputLayer?.tops?.[0] ?? null,
+        inputChannels: weightLayout?.segments?.[0]?.inputChannels ?? 4,
+        hiddenChannels: convolutionLayers[0]?.convolution?.numOutput ?? null,
+        outputChannels: outputLayer?.convolution?.numOutput ?? null,
+        kernel: convolutionLayers[0]
+            ? `${convolutionLayers[0].convolution.kernelW}x${convolutionLayers[0].convolution.kernelH}`
+            : null,
+        bytesRead: weightLayout?.bytesRead ?? null,
+        weightBinBytes: weightLayout?.byteLength ?? null
+    };
+}
+
+export {
+    NCNN_BINARY_PARAM_MAGIC,
+    NCNN_WEIGHT_FP16_STORAGE_TAG,
+    buildAllenkFdncnnWeightLayout,
+    halfToFloat,
+    parseAllenkFdncnnParam,
+    summarizeAllenkFdncnnModel
+};