Method applyPrefilter

pixelizer.js:685–735

(imageData, strength)

    }

    applyPrefilter(imageData, strength) {
        // 简单的双边滤波去除噪点
        const { data, width, height } = imageData;
        const filtered = new Uint8ClampedArray(data);
        
        const kernelRadius = 1;
        const spatialSigma = 1.0;
        const colorSigma = 30.0 * strength;
        
        for (let y = kernelRadius; y < height - kernelRadius; y++) {
            for (let x = kernelRadius; x < width - kernelRadius; x++) {
                const centerIndex = (y * width + x) * 4;
                const centerR = data[centerIndex];
                const centerG = data[centerIndex + 1];
                const centerB = data[centerIndex + 2];
                
                let sumR = 0, sumG = 0, sumB = 0, sumWeight = 0;
                
                for (let dy = -kernelRadius; dy <= kernelRadius; dy++) {
                    for (let dx = -kernelRadius; dx <= kernelRadius; dx++) {
                        const neighborIndex = ((y + dy) * width + (x + dx)) * 4;
                        const neighborR = data[neighborIndex];
                        const neighborG = data[neighborIndex + 1];
                        const neighborB = data[neighborIndex + 2];
                        
                        const spatialWeight = Math.exp(-(dx * dx + dy * dy) / (2 * spatialSigma * spatialSigma));
                        
                        const colorDistance = Math.sqrt(
                            (centerR - neighborR) ** 2 +
                            (centerG - neighborG) ** 2 +
                            (centerB - neighborB) ** 2
                        );
                        const colorWeight = Math.exp(-(colorDistance * colorDistance) / (2 * colorSigma * colorSigma));
                        
                        const weight = spatialWeight * colorWeight;
                        
                        sumR += neighborR * weight;
                        sumG += neighborG * weight;
                        sumB += neighborB * weight;
                        sumWeight += weight;
                    }
                }
                
                filtered[centerIndex] = Math.round(sumR / sumWeight);
                filtered[centerIndex + 1] = Math.round(sumG / sumWeight);
                filtered[centerIndex + 2] = Math.round(sumB / sumWeight);
            }
        }
        
        data.set(filtered);
    }

    async quantizeColors(imageData, colorCount, enableDithering) {
        // 使用现有的median cut算法