Barycentric Coordinates

Explore barycentric coordinates on a triangle, the setting for Sperner’s Lemma.

Barycentric coordinates are a coordinate system for describing points inside a triangle.

For a triangle with vertices \(A\), \(B\), and \(C\), any point \(P\) inside the triangle can be expressed as a weighted sum of the vertices: \[ P = iA + jB + kC \] where \(i\), \(j\), and \(k\) are the barycentric coordinates, satisfying \(i + j + k = 1\) and \(i, j, k \geq 0\). The barycentric coordinates can be interpreted as the relative areas of the sub-triangles formed with the point \(P\) and the vertices of the triangle.

Move the blue point around the triangle and watch how the barycentric coordinates change. The green point has the same coordinates in the red triangle; drag its vertices and watch it follow. With the keyboard, Tab to a point and use the arrow keys.

VM = window.VM
// Re-runs on a light/dark toggle, which repaints the traces below. The
// draggable dots are colored with CSS tokens, so they follow the theme
// without re-running the view (which would reset them).
vmTheme = Generators.observe(notify => VM.plotting.onThemeChange(notify))
chartColors = VM.plotting.colors(vmTheme)

// Created once, in a cell that depends on nothing reactive: the view and the
// paint cell below share its div.
baryPlot = VM.plotting.persistentPlot({height: "380px"})
baryXRange = [-0.15, 3.25]
baryYRange = [-0.15, 1.25]

// The standard triangle (0,0), (1,0), (0,1). The blue point lives in it, and
// its weights there are (1 - x - y, x, y): i weighs (0,0), j weighs (1,0) and
// k weighs (0,1), as in the prose below.
standardCorners = [{x: 0, y: 0}, {x: 1, y: 0}, {x: 0, y: 1}]
weightsOf = p => ({i: 1 - p.x - p.y, j: p.x, k: p.y})

// The point with weights (i, j, k) on the corners [A, B, C].
fromWeights = ({i, j, k}, [A, B, C]) => ({x: i * A.x + j * B.x + k * C.x, y: i * A.y + j * B.y + k * C.y})

// Where a dragged blue point goes: into the standard triangle (onto its
// nearest edge when dragged out), then onto a corner within 0.05 of it, so
// the extreme weights (1, 0, 0) and so on are easy to hit.
intoStandard = p => {
  let x = Math.max(0, p.x), y = Math.max(0, p.y)
  if (x + y > 1) {
    x = Math.min(1, Math.max(0, (x - y + 1) / 2))
    y = 1 - x
  }
  const corner = standardCorners.find(c => Math.hypot(c.x - x, c.y - y) < 0.05)
  return corner ? {x: corner.x, y: corner.y} : {x, y}
}

// The lines i, j, k = 0.1, 0.2, ..., 0.9 inside the triangle on `corners`,
// as one trace with null breaks.
gridLines = corners => {
  const xs = [], ys = []
  for (let n = 1; n < 10; n++) {
    const t = n / 10
    for (const [u, v] of [
      [{i: t, j: 1 - t, k: 0}, {i: t, j: 0, k: 1 - t}],
      [{i: 1 - t, j: t, k: 0}, {i: 0, j: t, k: 1 - t}],
      [{i: 1 - t, j: 0, k: t}, {i: 0, j: 1 - t, k: t}]
    ]) {
      const a = fromWeights(u, corners), b = fromWeights(v, corners)
      xs.push(a.x, b.x, null)
      ys.push(a.y, b.y, null)
    }
  }
  return {xs, ys}
}

// The chart is the input: baryPoints is [P, A, B, C], the blue point and the
// red triangle's corners, and every move re-runs the cells that read it.
viewof baryPoints = VM.plotting.draggablePoints(baryPlot, {
  value: [{x: 0.3, y: 0.4}, {x: 1.5, y: 0}, {x: 3, y: 0}, {x: 2, y: 1}],
  label: ["Blue point", "Corner A", "Corner B", "Corner C"],
  color: ["var(--vm-color-fn)", "var(--vm-color-alt)", "var(--vm-color-alt)", "var(--vm-color-alt)"],
  xBounds: baryXRange, yBounds: baryYRange,
  step: {x: 0.01, y: 0.01},
  constrain: (p, index) => index === 0 ? intoStandard(p) : p,
  format: (p, index) => {
    if (index > 0) return `x ${p.x.toFixed(2)}, y ${p.y.toFixed(2)}`
    const w = weightsOf(p)
    return `i ${w.i.toFixed(2)}, j ${w.j.toFixed(2)}, k ${w.k.toFixed(2)}`
  }
})

// Paints the chart the view lives on. No output: the chart is already on the
// page, in the cell above.
{
  const [P, ...corners] = baryPoints
  const [A, B, C] = corners
  const image = fromWeights(weightsOf(P), corners)
  const triangle = ([U, V, W], line, fillcolor) => ({
    x: [U.x, V.x, W.x, U.x], y: [U.y, V.y, W.y, U.y], mode: "lines", line,
    fill: fillcolor ? "toself" : "none", fillcolor, hoverinfo: "skip"
  })
  const grid = (cs, color) => {
    const {xs, ys} = gridLines(cs)
    return {x: xs, y: ys, mode: "lines", line: {color, width: 1}, hoverinfo: "skip"}
  }
  const label = (p, text) => ({x: p.x, y: p.y, text, showarrow: false, yshift: 16, font: {size: 14, color: chartColors.alt}})
  return baryPlot([
    grid(standardCorners, VM.plotting.alpha(chartColors.muted, 0.5)),
    triangle(standardCorners, {color: chartColors.ink, width: 1.5}, VM.plotting.alpha(chartColors.ink, 0.12)),
    grid(corners, VM.plotting.alpha(chartColors.muted, 0.5)),
    triangle(corners, {color: chartColors.alt, width: 1.5}),
    {x: [image.x], y: [image.y], mode: "markers", marker: {color: chartColors.ok, size: 12}, hoverinfo: "skip"}
  ], {
    showlegend: false, dragmode: false, hovermode: false,
    // Fixed axes, so a drag beside a point doesn't pan the chart; equal
    // scales, so the triangles keep their shapes.
    xaxis: {range: baryXRange, fixedrange: true, zeroline: false, showgrid: false},
    yaxis: {range: baryYRange, fixedrange: true, zeroline: false, showgrid: false, scaleanchor: "x"},
    annotations: [label(A, "A"), label(B, "B"), label(C, "C")]
  }, {...VM.plotting.config(), displayModeBar: false})
}

{
  const [P, ...corners] = baryPoints
  const w = weightsOf(P)
  const image = fromWeights(w, corners)
  return html`<p>i = <b>${w.i.toFixed(2)}</b>, j = <b>${w.j.toFixed(2)}</b>, k = <b>${w.k.toFixed(2)}</b>; the green point is (<b>${image.x.toFixed(2)}</b>, <b>${image.y.toFixed(2)}</b>)</p>`
}

Consider the triangle with vertices \((0, 0)\), \((1, 0)\), and \((0, 1)\). A point \((x, y)\) lies inside this triangle exactly when: \[ 0 \le x, \quad 0 \le y, \quad \text{and} \quad x + y \le 1 \] In this case, we can write the point \((x, y)\) as: \[ \begin{bmatrix} x \\ y \end{bmatrix} = (1 - x - y) \begin{bmatrix} 0 \\ 0 \end{bmatrix} + x \begin{bmatrix} 1 \\ 0 \end{bmatrix} + y \begin{bmatrix} 0 \\ 1 \end{bmatrix} \] So the barycentric coordinates of \((x, y)\) are \((1 - x - y, x, y)\), all of which are non-negative and sum to 1.

Now all you need to do is map \((0, 0)\), \((1, 0)\), and \((0, 1)\) to the vertices \(A\), \(B\), and \(C\), respectively, via an affine transformation. Write \(T\) for the affine map sending \[ \begin{aligned} (0,0) &\mapsto A, \\ (1,0) &\mapsto B, \\ (0,1) &\mapsto C. \end{aligned} \] Being affine, \(T\) preserves weighted combinations whose coefficients sum to 1: \[ \begin{aligned} &T\big((1-x-y)(0,0) + x(1,0) + y(0,1)\big) \\ &= (1-x-y)\,T(0,0) + x\,T(1,0) + y\,T(0,1) \\ &= (1-x-y)A + xB + yC. \end{aligned} \] The left-hand side is just \(T(x, y)\), so the barycentric coordinates of \(T(x,y)\) with respect to \(A, B, C\) are exactly \((1-x-y, x, y)\) — the same triple as the barycentric coordinates of \((x,y)\) with respect to the standard triangle. This is why the formula transfers unchanged to any triangle.