Otsu算法自实现求助：求阈值实现方案及改进建议

Hey there! Great job getting the foundational parts of Otsu's algorithm up and running—you’re already over the hump. Let’s walk through how to wrap up the threshold selection and binarization steps with clear, actionable steps.

Otsu’s core logic hinges on selecting the threshold that minimizes the within-class variance (or equivalently, maximizes between-class variance—they’re two sides of the same coin). Here’s how to implement it:

Step-by-Step Breakdown #

• First, make sure you have a precomputed grayscale histogram (length 256 for 8-bit images, where histogram[i] is the number of pixels with gray value i). You probably already used this for calculating weights/means, but double-check it’s accurate.
• Initialize two tracking variables:
  • minWithinClassVariance: Set to a very large value (like Double.MAX_VALUE) since we’re looking for the smallest variance.
  • optimalThreshold: Start at 0, we’ll update this as we iterate.
• Loop through every possible threshold t from 0 to 255:
  1. Use your existing code to calculate the background (pixels ≤ t) weight ω₀, mean μ₀, and variance σ₀².
  2. Calculate the foreground (pixels > t) weight ω₁, mean μ₁, and variance σ₁² (you can reuse your background logic here, just subtract from global totals to avoid redundant loops).
  3. Compute the within-class variance: currentVariance = ω₀ * σ₀² + ω₁ * σ₁².
  4. If currentVariance is smaller than minWithinClassVariance, update minWithinClassVariance and set optimalThreshold to t.
• Skip thresholds where ω₀ or ω₁ is 0 (all pixels are background or foreground)—this avoids division-by-zero errors and meaningless calculations.

Quick Pseudocode Example #

int optimalThreshold = 0;
double minVariance = Double.MAX_VALUE;
int totalPixels = width * height;
long totalSum = 0; // Precomputed sum of (grayValue * pixelCount) for all grays
long totalSumSquared = 0; // Precomputed sum of (grayValue² * pixelCount) for all grays

// Precompute totalSum and totalSumSquared first
for (int i = 0; i < 256; i++) {
    totalSum += (long) i * histogram[i];
    totalSumSquared += (long) i * i * histogram[i];
}

for (int t = 0; t < 256; t++) {
    // Calculate background stats
    int bgCount = 0;
    long bgSum = 0;
    long bgSumSquared = 0;
    for (int i = 0; i <= t; i++) {
        bgCount += histogram[i];
        bgSum += (long) i * histogram[i];
        bgSumSquared += (long) i * i * histogram[i];
    }
    
    // Skip edge cases where all pixels are bg or fg
    if (bgCount == 0 || bgCount == totalPixels) continue;
    
    double ω₀ = (double) bgCount / totalPixels;
    double μ₀ = (double) bgSum / bgCount;
    double σ₀² = (double) bgSumSquared / bgCount - (μ₀ * μ₀);
    
    // Calculate foreground stats using global totals
    int fgCount = totalPixels - bgCount;
    long fgSum = totalSum - bgSum;
    long fgSumSquared = totalSumSquared - bgSumSquared;
    
    double ω₁ = (double) fgCount / totalPixels;
    double μ₁ = (double) fgSum / fgCount;
    double σ₁² = (double) fgSumSquared / fgCount - (μ₁ * μ₁);
    
    // Compute and compare variance
    double currentVariance = ω₀ * σ₀² + ω₁ * σ₁²;
    if (currentVariance < minVariance) {
        minVariance = currentVariance;
        optimalThreshold = t;
    }
}

Once you have your optimal threshold, binarization is straightforward—just map every pixel to black or white based on the threshold:

Step-by-Step #

• Iterate over every pixel in your image (use your existing width/height values).
• For each pixel’s gray value:
  • If pixelValue ≤ optimalThreshold, set it to 0 (black, background).
  • Else, set it to 255 (white, foreground).
• If you’re working with a color image, convert it to grayscale first (you likely already did this to get width/height and stats, but just a reminder).

Pseudocode Example #

// Assuming image is a 2D array of grayscale values (0-255)
for (int y = 0; y < height; y++) {
    for (int x = 0; x < width; x++) {
        int pixel = image[y][x];
        image[y][x] = (pixel <= optimalThreshold) ? 0 : 255;
    }
}

• Precompute global totals (totalSum, totalSumSquared) once instead of recalculating them in every threshold loop—this cuts down on redundant work and speeds up the algorithm.
• Handle edge cases explicitly: if all pixels are the same gray value, set the threshold to that value to avoid crashes.
• In Java, use BufferedImage.getRaster() to access pixel data directly instead of getRGB()/setRGB()—it’s much faster for large images.
• Debug by printing the within-class variance values for each threshold—you should see a clear dip at the optimal threshold.

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