求Matlab中Wiener2Filter的Java等价实现（安卓图像处理应用）

Great question! I’ve worked on porting MATLAB’s wiener2 to Android before, so I can walk you through exactly how to implement an equivalent adaptive Wiener filter in Java for your image processing app.

Core Background on wiener2 #

First, let’s recap what MATLAB’s wiener2 does: it’s an adaptive Wiener filter that reduces noise by using local pixel statistics. For each pixel, it calculates the local mean and local variance within a specified window (default 3x3), then applies this formula to compute the output pixel:

output = local_mean + (noise_variance / (local_variance + ε)) * (input_pixel - local_mean)

• noise_variance: Estimated automatically by MATLAB as the average of all local variances in the image, or you can specify it manually.
• ε: A tiny value (like 1e-6) to avoid division by zero when local variance is near zero (flat regions).

Step-by-Step Implementation for Android #

Android uses Bitmap for image handling, so we’ll work with pixel arrays, optimize with integral images (to speed up local statistic calculations), and handle edge cases like boundary pixels.

1. Convert Bitmap to Processable Pixel Data

First, we’ll convert the input Bitmap to a grayscale pixel array (or split into RGB channels for color images). For grayscale, we use the standard luminance formula: 0.299*R + 0.587*G + 0.114*B.

2. Estimate Noise Variance

If you don’t specify a noise variance, we calculate it by averaging the local variances across the entire image—this matches how MATLAB’s wiener2 works.

3. Apply Adaptive Wiener Filter

We use integral images to compute local means and variances in O(1) time per pixel, which is way faster than iterating over each window for every pixel (critical for mobile performance).

4. Convert Back to Bitmap

Once processing is done, we convert the filtered pixel array back to an ARGB Bitmap.

Full Java Code Example #

Here’s a complete implementation for grayscale images (easily extended to color):

import android.graphics.Bitmap;
import android.graphics.Color;

public class WienerFilter {

    public Bitmap applyWiener2(Bitmap inputBitmap, int windowSize) {
        int width = inputBitmap.getWidth();
        int height = inputBitmap.getHeight();

        // Convert input Bitmap to grayscale pixel array
        int[] grayPixels = new int[width * height];
        inputBitmap.getPixels(grayPixels, 0, width, 0, 0, width, height);
        for (int i = 0; i < grayPixels.length; i++) {
            int pixel = grayPixels[i];
            int gray = (int) (0.299 * Color.red(pixel) + 0.587 * Color.green(pixel) + 0.114 * Color.blue(pixel));
            grayPixels[i] = gray;
        }

        // Estimate noise variance (matches MATLAB's auto-estimation)
        double noiseVariance = estimateNoiseVariance(grayPixels, width, height, windowSize);

        // Compute integral images for fast local stats
        long[] integralSum = computeIntegralSum(grayPixels, width, height);
        long[] integralSumSq = computeIntegralSumSquared(grayPixels, width, height);

        int halfWindow = windowSize / 2;
        double eps = 1e-6;
        int[] outputGray = new int[width * height];

        // Process each pixel
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                // Clamp window to image boundaries (avoids out-of-bounds errors)
                int x1 = Math.max(0, x - halfWindow);
                int x2 = Math.min(width - 1, x + halfWindow);
                int y1 = Math.max(0, y - halfWindow);
                int y2 = Math.min(height - 1, y + halfWindow);

                int windowArea = (x2 - x1 + 1) * (y2 - y1 + 1);

                // Calculate local mean using integral sum
                long sum = getIntegralRegionSum(integralSum, width, x1, y1, x2, y2);
                double localMean = sum / (double) windowArea;

                // Calculate local variance: E[x²] - (E[x])²
                long sumSq = getIntegralRegionSum(integralSumSq, width, x1, y1, x2, y2);
                double localMeanSq = sumSq / (double) windowArea;
                double localVariance = localMeanSq - localMean * localMean;

                // Apply Wiener formula
                int inputPixel = grayPixels[y * width + x];
                double filteredPixel = localMean + (noiseVariance / (localVariance + eps)) * (inputPixel - localMean);

                // Clamp to valid 0-255 range
                outputGray[y * width + x] = (int) Math.max(0, Math.min(255, filteredPixel));
            }
        }

        // Convert filtered grayscale back to ARGB Bitmap
        Bitmap outputBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        int[] argbPixels = new int[width * height];
        for (int i = 0; i < argbPixels.length; i++) {
            int gray = outputGray[i];
            argbPixels[i] = Color.argb(255, gray, gray, gray);
        }
        outputBitmap.setPixels(argbPixels, 0, width, 0, 0, width, height);

        return outputBitmap;
    }

    // Estimate noise variance as average of all local variances
    private double estimateNoiseVariance(int[] grayPixels, int width, int height, int windowSize) {
        long[] integralSum = computeIntegralSum(grayPixels, width, height);
        long[] integralSumSq = computeIntegralSumSquared(grayPixels, width, height);
        int halfWindow = windowSize / 2;
        double totalVariance = 0;
        int pixelCount = width * height;

        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int x1 = Math.max(0, x - halfWindow);
                int x2 = Math.min(width - 1, x + halfWindow);
                int y1 = Math.max(0, y - halfWindow);
                int y2 = Math.min(height - 1, y + halfWindow);

                int windowArea = (x2 - x1 + 1) * (y2 - y1 + 1);
                long sum = getIntegralRegionSum(integralSum, width, x1, y1, x2, y2);
                double mean = sum / (double) windowArea;
                long sumSq = getIntegralRegionSum(integralSumSq, width, x1, y1, x2, y2);
                double meanSq = sumSq / (double) windowArea;

                totalVariance += (meanSq - mean * mean);
            }
        }

        return totalVariance / pixelCount;
    }

    // Compute integral image for pixel sums
    private long[] computeIntegralSum(int[] pixels, int width, int height) {
        long[] integral = new long[width * height];
        integral[0] = pixels[0];

        // Fill first row
        for (int x = 1; x < width; x++) {
            integral[x] = integral[x - 1] + pixels[x];
        }

        // Fill first column
        for (int y = 1; y < height; y++) {
            integral[y * width] = integral[(y - 1) * width] + pixels[y * width];
        }

        // Fill rest of the integral image
        for (int y = 1; y < height; y++) {
            for (int x = 1; x < width; x++) {
                int idx = y * width + x;
                integral[idx] = pixels[idx] + integral[idx - 1] + integral[idx - width] - integral[idx - width - 1];
            }
        }
        return integral;
    }

    // Compute integral image for squared pixel sums
    private long[] computeIntegralSumSquared(int[] pixels, int width, int height) {
        long[] integral = new long[width * height];
        integral[0] = (long) pixels[0] * pixels[0];

        // Fill first row
        for (int x = 1; x < width; x++) {
            integral[x] = integral[x - 1] + (long) pixels[x] * pixels[x];
        }

        // Fill first column
        for (int y = 1; y < height; y++) {
            integral[y * width] = integral[(y - 1) * width] + (long) pixels[y * width] * pixels[y * width];
        }

        // Fill rest of the integral image
        for (int y = 1; y < height; y++) {
            for (int x = 1; x < width; x++) {
                int idx = y * width + x;
                long pixelSq = (long) pixels[idx] * pixels[idx];
                integral[idx] = pixelSq + integral[idx - 1] + integral[idx - width] - integral[idx - width - 1];
            }
        }
        return integral;
    }

    // Get sum of pixels in region (x1,y1) to (x2,y2) using integral image
    private long getIntegralRegionSum(long[] integral, int width, int x1, int y1, int x2, int y2) {
        long total = integral[y2 * width + x2];
        if (x1 > 0) total -= integral[y2 * width + (x1 - 1)];
        if (y1 > 0) total -= integral[(y1 - 1) * width + x2];
        if (x1 > 0 && y1 > 0) total += integral[(y1 - 1) * width + (x1 - 1)];
        return total;
    }
}

Extending to Color Images #

To handle color images, simply split the input Bitmap into R, G, B channels, apply the applyWiener2 logic to each channel separately, then merge the filtered channels back into an ARGB Bitmap. The adaptive Wiener filter works independently on each color channel without issues.

Performance Optimizations #

• Integral Images: This implementation uses integral images to reduce the time complexity from O(WHwindowSize²) to O(W*H), which is crucial for mobile devices.
• RenderScript: For very large images, consider using Android’s RenderScript to parallelize the pixel processing. It’s designed for high-performance image processing and can significantly speed up filtering.
• Window Size: MATLAB uses a 3x3 window by default. For noisier images, try a 5x5 window—but keep in mind larger windows will result in more blurring.

内容的提问来源于stack exchange，提问作者EdyAzar