Introduction

Tune an old AM radio and you hear a voice riding on a high-frequency carrier wave. The voice is the envelope — the slow shape that squeezes and stretches the fast oscillation. Engineers have known for a century that extracting that envelope is the key to demodulating the signal. But what mathematical operation peels the envelope away from the carrier?

The answer is the Hilbert transform, introduced by David Hilbert in the early twentieth century. It shifts every frequency component of a signal by exactly 90 degrees — turning every cosine into a sine, every sine into a negative cosine — without changing any amplitudes. From that phase-shifted copy, called the quadrature signal, you can reconstruct an envelope that tracks the signal's instantaneous strength, and a phase whose rate of change gives you the instantaneous frequency.

Together, the original signal x(t)x(t) and its Hilbert transform x^(t)\hat{x}(t) form the analytic signal: the complex-valued function z(t)=x(t)+i x^(t)z(t) = x(t) + i\,\hat{x}(t). Its magnitude ∣z(t)∣|z(t)| is the envelope; its argument arg⁡z(t)\arg z(t) is the instantaneous phase. This single construction lies at the heart of AM demodulation, seismic analysis, biomedical signal processing, and much of modern communications.

Track the Envelope

The canvas below shows a tone whose amplitude is modulated by a slow sinusoid. The blue curve is the raw signal x(t)x(t); the orange curve is the envelope ∣z(t)∣|z(t)| recovered via the Hilbert transform. Use the sliders to change the carrier frequency and the modulation depth — watch the envelope cling to the peaks of the carrier no matter how you tune it.

<!-- Canvas demo: AM-modulated tone + Hilbert envelope -->
<div class="controls">
  <label>Carrier frequency: <span id="fc-val"></span> Hz
    <input type="range" id="fc" min="4" max="20" value="10" step="1">
  </label>
  <label>Modulation depth: <span id="mod-val"></span>%
    <input type="range" id="mod" min="0" max="100" value="60" step="5">
  </label>
</div>
<canvas id="cv" width="560" height="280"></canvas>
<div class="legend">
  <span class="dot blue"></span> Signal x(t)
  <span class="dot orange"></span> Envelope |z(t)|
</div>
<p class="note" id="note"></p>

/* Styles for the Hilbert transform envelope demo */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; }
.controls { display: flex; flex-direction: column; gap: .4rem; margin-bottom: .6rem; }
label { font-size: .88rem; display: flex; align-items: center; gap: .5rem; }
input[type=range] { flex: 1; accent-color: #1d3557; }
canvas { display: block; width: 100%; max-width: 560px; border: 1px solid #cdd9e3;
         border-radius: 8px; background: #f8fafc; }
.legend { font-size: .82rem; display: flex; gap: 1rem; margin-top: .4rem; align-items: center; }
.dot { display: inline-block; width: 12px; height: 12px; border-radius: 50%; }
.dot.blue { background: #1d6fa5; }
.dot.orange { background: #e07020; }
.note { font-size: .82rem; color: #555; margin: .4rem 0 0; min-height: 1.2em; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Discrete Hilbert transform via FFT — builds the analytic signal and extracts the envelope
const N = 512;   // number of samples (must be a power of 2 for the FFT)
const T = 1.0;   // signal duration in seconds
const dt = T / N;

// In-place radix-2 Cooley-Tukey FFT (forward, unnormalized)
function fft(re, im) {
  const n = re.length;
  for (let i = 1, j = 0; i < n; i++) {
    let bit = n >> 1;
    for (; j & bit; bit >>= 1) j ^= bit;
    j ^= bit;
    if (i < j) {
      [re[i], re[j]] = [re[j], re[i]];
      [im[i], im[j]] = [im[j], im[i]];
    }
  }
  for (let len = 2; len <= n; len <<= 1) {
    const ang = -2 * Math.PI / len;
    const wr = Math.cos(ang), wi = Math.sin(ang);
    for (let i = 0; i < n; i += len) {
      let cr = 1, ci = 0;
      for (let k = 0; k < len / 2; k++) {
        const ur = re[i + k], ui = im[i + k];
        const vr = re[i + k + len / 2] * cr - im[i + k + len / 2] * ci;
        const vi = re[i + k + len / 2] * ci + im[i + k + len / 2] * cr;
        re[i + k] = ur + vr; im[i + k] = ui + vi;
        re[i + k + len / 2] = ur - vr; im[i + k + len / 2] = ui - vi;
        const tmp = cr * wr - ci * wi; ci = cr * wi + ci * wr; cr = tmp;
      }
    }
  }
}

// Inverse FFT: swap re/im, forward FFT, then normalize
function ifft(re, im) {
  fft(im, re);
  for (let i = 0; i < re.length; i++) { re[i] /= re.length; im[i] /= re.length; }
}

// Compute the Hilbert envelope via the analytic signal
function hilbertEnvelope(x) {
  const re = x.slice(), im = new Array(N).fill(0);
  fft(re, im);
  // double positive frequencies, zero out negative frequencies
  for (let k = 1; k < N / 2; k++) { re[k] *= 2; im[k] *= 2; }
  for (let k = N / 2 + 1; k < N; k++) { re[k] = 0; im[k] = 0; }
  ifft(re, im);
  // magnitude of the analytic signal = instantaneous amplitude
  return re.map((r, i) => Math.sqrt(r * r + im[i] * im[i]));
}

const cv = document.getElementById('cv');
const ctx = cv.getContext('2d');
const fcSlider = document.getElementById('fc');
const modSlider = document.getElementById('mod');
const fcVal = document.getElementById('fc-val');
const modVal = document.getElementById('mod-val');
const noteEl = document.getElementById('note');

function draw() {
  const fc = Number(fcSlider.value);
  const m  = Number(modSlider.value) / 100;
  fcVal.textContent  = fc;
  modVal.textContent = Math.round(m * 100);

  // build AM-modulated signal: (1-m+m*cos(2*pi*2*t)) * cos(2*pi*fc*t)
  const x = [];
  for (let n = 0; n < N; n++) {
    const t = n * dt;
    const env = 1 - m + m * Math.cos(2 * Math.PI * 2 * t);
    x.push(env * Math.cos(2 * Math.PI * fc * t));
  }

  const env = hilbertEnvelope(x);

  const W = cv.width, H = cv.height;
  ctx.clearRect(0, 0, W, H);

  const mid = H / 2;
  const scale = mid * 0.88;

  // draw the raw signal in blue
  ctx.beginPath();
  ctx.strokeStyle = '#1d6fa5';
  ctx.lineWidth = 1.5;
  for (let i = 0; i < N; i++) {
    const px = (i / N) * W;
    const py = mid - x[i] * scale;
    i === 0 ? ctx.moveTo(px, py) : ctx.lineTo(px, py);
  }
  ctx.stroke();

  // draw the positive envelope in orange
  ctx.beginPath();
  ctx.strokeStyle = '#e07020';
  ctx.lineWidth = 2;
  for (let i = 0; i < N; i++) {
    const px = (i / N) * W;
    const py = mid - env[i] * scale;
    i === 0 ? ctx.moveTo(px, py) : ctx.lineTo(px, py);
  }
  ctx.stroke();

  // draw the negative mirror envelope as a dashed orange line
  ctx.beginPath();
  ctx.strokeStyle = '#e07020';
  ctx.lineWidth = 2;
  ctx.setLineDash([4, 4]);
  for (let i = 0; i < N; i++) {
    const px = (i / N) * W;
    const py = mid + env[i] * scale;
    i === 0 ? ctx.moveTo(px, py) : ctx.lineTo(px, py);
  }
  ctx.stroke();
  ctx.setLineDash([]);

  // update the explanatory note below the canvas
  if (m >= 0.99) {
    noteEl.textContent = '100% modulation — the signal touches zero; the instantaneous phase jumps by π at each zero crossing.';
  } else {
    noteEl.textContent = i18nFmt('Carrier %fc% Hz · modulation %mod%% — the envelope (orange) tracks the amplitude peaks of the carrier (blue).', { fc: fc, mod: Math.round(m * 100) });
  }
}

fcSlider.addEventListener('input', draw);
modSlider.addEventListener('input', draw);
draw();
Result
Console

Notice that the envelope never dips below zero and always touches the absolute peaks of the carrier. When modulation depth is 100 % the signal briefly touches zero — complete suppression. That moment corresponds to a π\pi-radian jump in the instantaneous phase, a signature the Hilbert transform detects cleanly.

The Real Math

What does it mean to shift every frequency by exactly 90 degrees?

  • In the time domain, the Hilbert transform is a convolution with the kernel h(t)=1πth(t) = \dfrac{1}{\pi t}. Because this kernel is not square-integrable, the integral must be taken as a Cauchy principal value — which is why the transform existed in analysis long before it was given an engineering name.
  • In the frequency domain, it is multiplication by −i⋅sgn⁡(f)-i \cdot \operatorname{sgn}(f): positive frequencies are multiplied by −i-i (a −90°-90° rotation), negative frequencies by +i+i. This is a pure phase operation; no amplitude is changed.
  • Building the analytic signal: set the negative-frequency content of the spectrum to zero and double the positive side. The result, inverse-transformed back to the time domain, is z(t)=x(t)+i x^(t)z(t) = x(t) + i\,\hat{x}(t), whose real part recovers x(t)x(t) exactly.
  • Instantaneous amplitude and frequency: the envelope is A(t)=∣z(t)∣=x(t)2+x^(t)2A(t) = |z(t)| = \sqrt{x(t)^{2} + \hat{x}(t)^{2}}, and the instantaneous frequency is fi(t)=12πddtarg⁡z(t)f_i(t) = \dfrac{1}{2\pi}\dfrac{d}{dt}\arg z(t).

The transform was fully characterized by David Hilbert around 1905 in his work on integral equations, and independently found useful by electrical engineers studying single-sideband modulation in the 1920s. It is not "computationally hard" in the complexity-theory sense — the FFT computes it in O(nlog⁡n)O(n \log n) — but its conceptual depth is substantial: it connects Fourier analysis with complex analysis, turning a real signal into a rotating phasor in the complex plane.

Where It Matters

Anywhere a signal is a fast oscillation whose strength or pitch changes slowly, the analytic signal is the right tool:

  • AM radio demodulation: the classic application. The envelope ∣z(t)∣|z(t)| is the audio, recoverable without a phase-locked carrier reference.
  • Seismology: body-wave envelopes reveal the energy arrival pattern of earthquakes independent of the carrier frequency of the waves.
  • Biomedical signals: ECG R-peak detection and EEG band-power estimation both use the Hilbert envelope to track signal energy over time.
  • Radar and sonar: pulse envelopes determine range resolution; instantaneous frequency tracks Doppler shifts.
  • Speech and music: empirical mode decomposition (EMD) and the Hilbert-Huang transform decompose complex audio into intrinsic mode functions, each with a meaningful envelope and frequency track.
  • Optical coherence tomography: the coherence envelope of a broadband light source locates tissue boundaries with micron precision.

The transform also underpins single-sideband (SSB) modulation — one of the most bandwidth-efficient radio schemes ever devised — and feeds directly into the Fourier machinery that runs on every digital signal processor made today.

Conclusion

The Hilbert transform answers a deceptively simple question: if a signal is a fast oscillation riding on a slow shape, how do you read the shape? The answer — shift every frequency by 90 degrees, form the analytic signal, and take its magnitude — is elegant, computationally cheap, and mathematically deep. It connects Cauchy's principal-value integrals, Fourier duality, and the geometry of the complex plane in a single formula.

The next time you hear a voice on AM radio, watch a seismogram trace the arrival of P-waves, or see an ECG machine highlight heartbeats, you are looking at the Hilbert transform at work. A century-old piece of pure mathematics, quietly running inside nearly every signal-processing pipeline on the planet.

Share this article

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

Comments

Loading comments...

https://www.kipuhub.com/en/article/hilbert-transform-envelope/Content licensed under CC BY-NC 4.0.