Introduction

Every camera sensor delivers shades of gray. Every vision pipeline eventually needs a clean yes/no decision: is this pixel foreground or background? That step is called binarization, and it demands a single number — a threshold TT — that splits the 256 possible brightness levels into two groups.

Pick TT too low and the background bleeds into your foreground. Pick it too high and fine details vanish. For decades, engineers set TT by eye. In 1979, Nobuyuki Otsu published a one-page paper that made the choice automatic and optimal: scan the histogram once, find the TT that maximizes the variance between the two resulting classes, and you are done.

The method is still the default in OpenCV, ImageJ, and every other serious imaging library today — not because nothing better exists for special cases, but because it works remarkably well on the enormous range of problems where foreground and background differ in brightness.

Try It

The demo below generates a synthetic grayscale image of a bright disk on a dark background. Drag the threshold slider to see manual binarization, then press Run Otsu to let the algorithm pick the threshold automatically by maximizing between-class variance.

<!-- Otsu thresholding demo — grayscale image binarization -->
<p class="hint">A synthetic image (bright disk, dark background) is shown left. Drag the <b>threshold slider</b> to binarize manually — then press <b>Run Otsu</b> to find the optimal threshold automatically. The variance curve shows between-class variance at every possible threshold; Otsu's method picks the peak.</p>
<div class="canvases">
  <div class="canvas-wrap">
    <div class="canvas-label">Original</div>
    <canvas id="cvOrig" width="160" height="120"></canvas>
  </div>
  <div class="canvas-wrap">
    <div class="canvas-label">Binary</div>
    <canvas id="cvBin" width="160" height="120"></canvas>
  </div>
  <div class="canvas-wrap">
    <div class="canvas-label">Variance</div>
    <canvas id="cvVar" width="160" height="120"></canvas>
  </div>
</div>
<div class="slider-row">
  <label for="thresh">Threshold: <span id="threshVal">128</span></label>
  <input type="range" id="thresh" min="0" max="255" value="128">
</div>
<div class="status" id="status"></div>
<div class="btns">
  <button id="btnOtsu" type="button">Run Otsu</button>
  <button id="btnReset" type="button" class="ghost">Reset</button>
</div>

/* Layout and palette for the Otsu thresholding demo */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: .5rem; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .8rem; line-height: 1.45; }
.canvases { display: flex; gap: .6rem; flex-wrap: wrap; margin-bottom: .7rem; }
.canvas-wrap { display: flex; flex-direction: column; align-items: center; gap: .2rem; }
.canvas-label { font-size: .78rem; font-weight: 600; color: #556; text-transform: uppercase; letter-spacing: .04em; }
canvas { border: 1px solid #cdd9e3; border-radius: 6px; display: block; }
.slider-row { display: flex; align-items: center; gap: .7rem; margin: .4rem 0; }
.slider-row label { font-size: .9rem; white-space: nowrap; min-width: 10em; }
input[type=range] { flex: 1; accent-color: #1d3557; }
.status { font-size: .95rem; font-weight: 600; min-height: 1.4em; margin: .4rem 0; }
.status.ok { color: #0a7d33; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));

// Generate a synthetic grayscale image — a bright disk on a dark background
const W = 160, H = 120;
const cvOrig = document.getElementById('cvOrig');
const cvBin  = document.getElementById('cvBin');
const cvVar  = document.getElementById('cvVar');
const ctxO = cvOrig.getContext('2d');
const ctxB = cvBin.getContext('2d');
const ctxV = cvVar.getContext('2d');
const slider = document.getElementById('thresh');
const threshVal = document.getElementById('threshVal');
const statusEl = document.getElementById('status');

// Fill pixel array: disk pixels are bright, background is dark, add noise
const pixels = new Uint8Array(W * H);
const cx = W / 2, cy = H / 2, r = 38;
for (let y = 0; y < H; y++) {
  for (let x = 0; x < W; x++) {
    const dx = x - cx, dy = y - cy;
    const disk = dx * dx + dy * dy < r * r;
    // add Gaussian-like noise to make the histogram realistic
    const base = disk ? 180 : 50;
    const noise = Math.floor((Math.random() - 0.5) * 40);
    pixels[y * W + x] = Math.max(0, Math.min(255, base + noise));
  }
}

// Draw the original grayscale image onto the canvas
function drawOriginal() {
  const img = ctxO.createImageData(W, H);
  for (let i = 0; i < pixels.length; i++) {
    const g = pixels[i];
    img.data[i * 4]     = g;
    img.data[i * 4 + 1] = g;
    img.data[i * 4 + 2] = g;
    img.data[i * 4 + 3] = 255;
  }
  ctxO.putImageData(img, 0, 0);
}

// Build normalized histogram from pixel values
function buildHistogram() {
  const hist = new Float64Array(256);
  for (let i = 0; i < pixels.length; i++) hist[pixels[i]]++;
  const n = pixels.length;
  for (let i = 0; i < 256; i++) hist[i] /= n;
  return hist;
}
const hist = buildHistogram();

// Compute between-class variance curve using cumulative sums — between-class variance for all thresholds
function computeVarianceCurve(hist) {
  const varCurve = new Float64Array(256);
  let mu = 0;
  for (let i = 0; i < 256; i++) mu += i * hist[i];

  let w0 = 0, mu0 = 0;
  for (let t = 0; t < 256; t++) {
    w0 += hist[t];
    mu0 += t * hist[t];
    const w1 = 1 - w0;
    if (w0 <= 0 || w1 <= 0) { varCurve[t] = 0; continue; }
    const m0 = mu0 / w0;
    const m1 = (mu - mu0) / w1;
    varCurve[t] = w0 * w1 * (m0 - m1) * (m0 - m1);
  }
  return varCurve;
}
const varCurve = computeVarianceCurve(hist);

// Find the threshold that maximizes between-class variance — index of maximum between-class variance
function otsuThreshold(varCurve) {
  let best = -1, bestT = 0;
  for (let t = 0; t < 256; t++) {
    if (varCurve[t] > best) { best = varCurve[t]; bestT = t; }
  }
  return bestT;
}
const OTSU_T = otsuThreshold(varCurve);

// Draw binarized image using the given threshold
function drawBinary(t) {
  const img = ctxB.createImageData(W, H);
  for (let i = 0; i < pixels.length; i++) {
    const v = pixels[i] > t ? 255 : 0;
    img.data[i * 4]     = v;
    img.data[i * 4 + 1] = v;
    img.data[i * 4 + 2] = v;
    img.data[i * 4 + 3] = 255;
  }
  ctxB.putImageData(img, 0, 0);
}

// Draw the variance curve canvas with current threshold marker
function drawVarianceCurve(t) {
  ctxV.clearRect(0, 0, W, H);
  ctxV.fillStyle = '#f0f4f8';
  ctxV.fillRect(0, 0, W, H);
  const maxV = Math.max(...varCurve);
  // Draw variance curve line
  ctxV.beginPath();
  ctxV.strokeStyle = '#1d6fa4';
  ctxV.lineWidth = 1.5;
  for (let i = 0; i < 256; i++) {
    const px = (i / 255) * W;
    const py = H - (varCurve[i] / maxV) * (H - 4) - 2;
    i === 0 ? ctxV.moveTo(px, py) : ctxV.lineTo(px, py);
  }
  ctxV.stroke();
  // Draw red dashed line for the current manual threshold
  const tx = (t / 255) * W;
  ctxV.beginPath();
  ctxV.strokeStyle = '#e63946';
  ctxV.lineWidth = 1.5;
  ctxV.setLineDash([3, 3]);
  ctxV.moveTo(tx, 0);
  ctxV.lineTo(tx, H);
  ctxV.stroke();
  ctxV.setLineDash([]);
  // Draw green dashed line for the Otsu optimal threshold
  const ox = (OTSU_T / 255) * W;
  ctxV.beginPath();
  ctxV.strokeStyle = '#0a7d33';
  ctxV.lineWidth = 1.5;
  ctxV.setLineDash([2, 2]);
  ctxV.moveTo(ox, 0);
  ctxV.lineTo(ox, H);
  ctxV.stroke();
  ctxV.setLineDash([]);
}

// Refresh all visuals and status message
function update(t) {
  threshVal.textContent = t;
  drawBinary(t);
  drawVarianceCurve(t);
  const isOtsu = t === OTSU_T;
  statusEl.className = 'status' + (isOtsu ? ' ok' : '');
  statusEl.textContent = isOtsu
    ? i18nFmt('✓ Optimal Otsu threshold: T = %t%', { t: OTSU_T })
    : i18nFmt('Manual T = %t% (Otsu optimal: %opt%)', { t: t, opt: OTSU_T });
}

// Wire up slider and button events
slider.addEventListener('input', () => update(Number(slider.value)));
document.getElementById('btnOtsu').addEventListener('click', () => {
  slider.value = OTSU_T;
  update(OTSU_T);
});
document.getElementById('btnReset').addEventListener('click', () => {
  slider.value = 128;
  update(128);
});

// Initialize the demo
drawOriginal();
update(128);
Result
Console

Watch the variance curve above the slider: Otsu's threshold lands exactly at its peak. Moving the slider away from that peak always increases the overlap between the two brightness classes — the algorithm provably finds the global maximum in a single left-to-right scan.

The Math

Let L=256L = 256 be the number of gray levels and let pip_i be the fraction of pixels at level ii. Define cumulative sums up to a trial threshold tt:

ω0(t)=∑i=0tpi,μ0(t)=1ω0∑i=0ti⋅pi\omega_0(t) = \sum_{i=0}^{t} p_i, \quad \mu_0(t) = \frac{1}{\omega_0} \sum_{i=0}^{t} i \cdot p_i

and symmetrically ω1=1−ω0\omega_1 = 1 - \omega_0, μ1=(μ−μ0ω0)/ω1\mu_1 = (\mu - \mu_0 \omega_0)/\omega_1 where μ\mu is the global mean. The between-class variance is:

σB2(t)=ω0(t) ω1(t) (μ0(t)−μ1(t))2\sigma_B^2(t) = \omega_0(t)\,\omega_1(t)\,\bigl(\mu_0(t) - \mu_1(t)\bigr)^2

Otsu's algorithm simply finds T∗=arg⁡max⁡tσB2(t)T^* = \arg\max_t \sigma_B^2(t).

Key facts:

  • Exact and parameter-free. The search is over 256 candidates — no gradient descent, no hyperparameters, no training data.
  • O(L)O(L) time after building the histogram. Each σB2(t)\sigma_B^2(t) is computed in O(1)O(1) from running totals updated left-to-right.
  • Equivalent to minimizing within-class variance. Because total variance is fixed, maximizing between-class variance is the same as making each class as tight as possible around its own mean.
  • Assumes a bimodal histogram. The formula is optimal when the image has two dominant brightness modes — a foreground cluster and a background cluster. Multimodal scenes require multi-threshold generalizations.

The 1979 paper is one of the most-cited works in computer vision precisely because this simple closed-form derivation delivers a robust, practical result with zero user tuning.

Where It Matters

Otsu's method sits at the front of a remarkable number of image-processing pipelines:

  • Document scanning and OCR: converting a photographed page to black-and-white is the first step before any text recognition. Otsu's threshold adapts to each image's lighting without manual calibration.
  • Medical imaging: segmenting bone from soft tissue in X-rays, or nuclei from cytoplasm in microscopy slides, often reduces to a brightness threshold — Otsu finds it automatically.
  • Industrial inspection: detecting defects (scratches, inclusions, missing parts) on a production line requires separating the defect brightness from the background. Speed matters here, and Otsu's O(L)O(L) pass delivers.
  • Satellite and remote sensing: distinguishing water bodies from land, or snow from soil, in multispectral images is a thresholding problem at scale.
  • Pre-processing for deeper algorithms: even modern neural-network training pipelines sometimes begin with a classical binarization step to reduce noise before feeding data to a learned model.

The algorithm's reach extends beyond grayscale: any 1-D distribution with two modes — audio silence detection, network packet size classification, anomaly scoring — admits the same between-class variance trick.

Conclusion

Otsu's thresholding is a rare example of a problem that is both practically important and theoretically clean. The criterion — maximize the variance between the two pixel classes — has a closed-form solution, runs in a single left-to-right scan of 256 histogram bins, and requires no parameters at all.

Its longevity comes from that combination: it is fast enough for real-time pipelines, accurate enough for clinical imaging, and simple enough to understand in a single sitting. The next time you scan a document, read a barcode, or open an X-ray, there is a good chance a descendant of Nobuyuki Otsu's 1979 formula is silently deciding which pixels are foreground and which are background — one pass, one threshold, one clean answer.

For scenes with more than two brightness modes, the method generalizes naturally to multi-threshold Otsu, and related ideas appear in dimensionality reduction and pattern matching whenever a clean boundary between classes is needed.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/otsu-thresholding/Content licensed under CC BY-NC 4.0.