figure

package module
v0.10.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 11, 2026 License: MIT Imports: 20 Imported by: 0

README

A Go gopher in a wizard hat waving a wand that conjures bubbles holding a surface plot, a layered pie chart, a Smith chart and a ternary plot

figure

CI Coverage Go Reference

A grammar-driven plotting library for Go: one model, many backends, runs everywhere — built on the GoGPU stack.

Status: v0.x. The model is settled and the API is not frozen. The three seams that took positional scale arguments have been reshaped so that a chart can gain a dimension additively, and the dimension has arrived: figure/three draws a chart whose x, y and z are all data (ADR 0056, ADR 0060); v1.0.0 returns when the surface settles.

The name is the thesis: a figure is a chart that has been finished and placed, and what makes it one is the model behind it rather than the file it was saved as. One specification enters figure, a spectrum of output formats comes out.

A damped sine over a time axis, dark theme

What it is

One declarative chart specification, rendered through interchangeable backends. The core is pure Go with no dependencies at all — not "no cgo", literally nothing outside the standard library — and emits both vector formats, SVG and PDF. Add one module and the same specification renders to PNG and JPEG through gogpu/gg, still with CGO_ENABLED=0.

Dependencies Output
github.com/timzifer/figure stdlib only SVG, PDF, browser canvas
github.com/timzifer/figure/backend/gg GoGPU (gg), x/image — zero CGO PNG, JPEG, an in-memory surface
github.com/timzifer/figure/backend/window GoGPU (gogpu, gg) — zero CGO a native window
github.com/timzifer/figure/backend/gg/gpu GoGPU (gg/gpu, wgpu) — zero CGO — (switches the GPU tier on)
github.com/timzifer/figure/arrow/v18 apache/arrow-go — zero CGO — (a data source)

The browser is in the core too, because it needs nothing to be: a canvas 2D context is reached through syscall/js, which is the standard library (ADR 0017). Everything else is behind the same ir.Backend interface, in a module of its own, so what a program links is what it asked for: a server that renders SVG links nothing but the standard library, and a desktop program that opens a window links a window layer.

Install

The release check in CONTRIBUTING.md verifies each module outside the development workspace before it is tagged, so a published require line names a core that exists.

go get github.com/timzifer/figure                  # core: SVG and PDF, stdlib only
go get github.com/timzifer/figure/backend/gg       # raster: PNG and JPEG
go get github.com/timzifer/figure/backend/window   # a native window
go get github.com/timzifer/figure/backend/gg/gpu   # optional: the GPU tier
go get github.com/timzifer/figure/arrow/v18        # optional: plot Arrow data

Go 1.25 or newer (why).

Quick start

package main

import (
	"log"
	"math"

	"github.com/timzifer/figure"
	"github.com/timzifer/figure/geom"
	"github.com/timzifer/figure/palette"
	"github.com/timzifer/figure/scale"
	"github.com/timzifer/figure/theme"
)

func main() {
	xs := make([]float64, 200)
	ys := make([]float64, 200)
	for i := range xs {
		xs[i] = float64(i) / 20
		ys[i] = math.Sin(xs[i])
	}

	p := figure.New(
		figure.Theme(theme.Dark),
		figure.Size(800, 400),
		figure.Title("Signal"),
		figure.YTitle("amplitude"),
	)
	p.X(scale.Linear(scale.Nice()))
	p.Y(scale.Linear(scale.Nice()))
	p.Add(geom.Line(
		figure.Float64Columns(map[string][]float64{"x": xs, "y": ys}),
		geom.X("x"), geom.Y("y"),
		geom.Color(palette.Blue),
		geom.Tension(0.4),
	))

	if err := p.Render(figure.SVG("signal.svg")); err != nil {
		log.Fatal(err)
	}
}

For PDF or raster, swap the target — nothing else changes:

err := p.Render(figure.PDF("signal.pdf"))          // still stdlib only

import ggbackend "github.com/timzifer/figure/backend/gg"
err := p.Render(ggbackend.PNG("signal.png"))

A runnable version is in examples/signal.

Every figure in docs/gallery.md is rendered by backend/gg/cmd/gallery and re-checked in CI, so a picture cannot drift away from the code that produced it.
Three series with a legend Bars by region, coloured by value with a colourbar
Latency by service as violins, one per region within each service A patch antenna's reflection swept across its band, on a Smith chart
Requests per second through a service, drawn as a sankey diagram A million points drawn as a density raster

What it does

  • Scales — linear, time, log, symlog, ordinal. Extended-Wilkinson tick placement, calendar-unit time steps, minor ticks per decade, pinned tick sequences.
  • Marks — lines, points, bars, areas, steps, rects, boxplots, histograms, violins, ridgelines, hexbins, beeswarms, ECDFs, trends, contours, treemaps, icicles, sankeys, arcs, error bars, intervals, text, annotations — including a locus, a family of curves given by a formula rather than by data, which is what a Nichols diagram's closed-loop contours and a Smith chart's VSWR circles are.
  • Coordinate systems — Cartesian, polar (so a bar is a pie and an icicle is a sunburst), and Smith.
  • Three dimensions — figure/three draws a chart whose x, y and z are all data: a surface over a grid, a trajectory through a volume, a field of bars over two categoricals. It projects above the IR, so every backend draws one; the camera is a value the caller holds, so the host owns the drag; and a scene can be looked at from several cameras at once, which is what a static export and a printed page need.
  • Colour and size — qualitative palettes, sequential and diverging ramps, classed ramps, a size channel, and the legend, colourbar or size key that follows from which of them a layer was handed.
  • Layout — facets, subplot grids, secondary axes, guides solved by one constraint solver.
  • Output — SVG and PDF from the standard library alone; PNG, JPEG and an in-memory surface through one module; a browser canvas; a native window; an opt-in GPU tier.
  • Interaction — hit-testing, hover and click, zoom and pan, an overlay layer, clickable legends, linked views, keyed transitions, streaming data.
  • Reading — typeset notation in labels, and a description, a data table and per-mark semantics for a reader that is not an eye.

The long version, with what each one is for and which record decided it, is in docs/features.md.

Reading further
docs/gallery.md Every figure the library draws, rendered from the code that draws it.
docs/charts.md Chart forms and the programs that produce them: categories, stacks, pies and donuts, Smith charts, edge tables, boxes, distributions, bubbles, small multiples, secondary axes, label placement.
docs/interaction.md The browser, the native window, the GPU tier, live data, and a chart that follows its surface.
docs/scale-out.md What happens when a chart has more rows than the screen has pixels.
docs/reading.md Notation in labels, and charts that can be read without being seen.
docs/spec.md A chart as JSON, and plotting Arrow data.
docs/features.md The full feature surface.
docs/milestones.md How each capability arrived, and the argument that shaped it.

How it fits together

   Your spec  ──►  Model  ──►  IR  ──►  Backend  ──►  output
   ─────────      ─────      ────      ───────       ──────
   geoms          scales     ~8        backend/svg     SVG
   scales         coords     drawing   backend/pdf     PDF
   coords         layout     ops       backend/canvas  browser canvas
   theme          ticks                backend/gg      PNG / JPEG / a surface
   facets         panels               backend/window  a native window

The ir.Backend interface is the seam. Geoms never touch a renderer; a renderer never knows what a scale is. That is what lets figure stand on a young, fast-moving graphics stack without being welded to it — the whole gg adapter is about 300 lines (why that matters).

Things ride on that seam without widening it. A render can be watched, so that a pointer can be told which layer drew what it is over (ADR 0015); two frames can be compared, so that a surface repaints only what moved (ADR 0016); and a backend that can carry words, resize itself, or repaint part of a frame says so through an optional interface — ir.Semantics, ir.Resizer, ir.Partial — rather than through a method every backend would have to implement. No identity channel and no damage channel went into the drawing interface.

The native window is the same argument once more: it is a surface that draws with the raster backend and presents the result, so there is one implementation of every mark and a window shows what a file would (ADR 0021).

Documentation

  • CONCEPT.md — the design document: motivation, positioning, architecture, roadmap.
  • docs/adr — why each open question was answered the way it was.
  • docs/chart-types.md — every chart form, what draws it today, and what the missing ones would cost.
  • docs/benchmarks.md — the benchmark suite: what each benchmark measures, which numbers are gated, and the latest results.
  • docs/milestones.md — how the library was built, in the order it was built, with the argument behind each step.
  • pkg.go.dev — the API reference, generated from the doc comments.
  • CONTRIBUTING.md — building a five-module repository, how to regenerate golden files and figures, and how a release is tagged.
  • SECURITY.md — which versions get fixes, and how to report a vulnerability privately.
  • CODE_OF_CONDUCT.md — what participating here looks like.

A note on how this was built

Much of figure was written with an AI assistant — Claude, in Claude Code — in the loop, under human direction and review. The design decisions and the arguments in the ADRs are the ones a human signed off on; a good deal of the typing was not. What makes that workable is the same thing the rest of this README describes: every claim here is held up by a golden file, a test or a benchmark that CI runs on every commit, so the code is checked against the behaviour rather than against a plausible-sounding explanation of it.

License

MIT. The core links nothing; backend/gg links only permissively licensed code (gg is MIT, x/image is BSD-3-Clause). That is a requirement rather than a preference — figure must be embeddable by downstream projects under any license.

Documentation

Overview

Package figure turns one declarative chart specification into any output you need — SVG, PDF and a browser canvas today, raster through one more module, GPU and a native window through later ones — from the same model, with the same geometry.

The core module is pure Go and depends on nothing but the standard library. Both vector emitters are built in and need no rendering engine and no font stack, so a server that wants a chart as SVG or a report generator that wants one as PDF links nothing native and nothing young. The browser backend is built in for the same reason: a canvas 2D context is reached through syscall/js. Raster output lives in a separate module, github.com/timzifer/figure/backend/gg, which is still CGO-free.

Shape of the API

Build a plot, give it scales, add layers, render it to a target: 

src := figure.Float64Columns(map[string][]float64{"t": times, "y": values})

p := figure.New(
    figure.Theme(theme.Dark),
    figure.Size(800, 500),
    figure.Title("Signal"),
)
p.X(scale.Time())
p.Y(scale.Linear(scale.Nice()))
p.Add(geom.Line(src, geom.X("t"), geom.Y("y"), geom.Color(palette.Blue)))

err := p.Render(figure.SVG("signal.svg"))

Scales cover linear, time, log, symlog and ordinal/categorical axes; geoms cover lines, scatters, bars, areas, steps, boxplots and rects. A mark's colour can come from the data through scale.Sequential or scale.Diverging and geom.ColorBy, which contributes a colourbar beside the plot, and its size through scale.Size and geom.SizeBy, which contributes a key of sample marks — the bubble chart.

Distributions

geom.Histogram, geom.Violin, geom.Ridgeline, geom.Hexbin, geom.Beeswarm, geom.ECDF and geom.Trend summarise a column rather than plotting it. Each is a pure function in package stat with a determinism test, and each trains its axis on the summary: a histogram's Y axis holds counts that are nowhere in the data. 

p.X(scale.Ordinal())
p.Add(geom.Violin(src, geom.X("service"), geom.Y("latency"),
    geom.GroupBy("region")))

Annotations

geom.HLine, geom.VLine, geom.HBand, geom.VBand, geom.Segment, geom.Region and geom.Note add the marks that are not data — a threshold, a shaded window, a label pointing at what happened. They take values rather than a data source.

Many panels

Plot.Facet splits one plot into small multiples, one panel per value of a column; NewGrid puts several different plots on one canvas. Both lay their panels out with the same solver, so the axes line up either way. 

p.Facet(facet.Wrap("region", facet.Columns(3)))

Interaction

Plot.On registers a handler for hover, click, zoom or pan, and Plot.Live draws the chart into a surface that can be redrawn, pointed at, panned and zoomed. Each redraw repaints only what changed, and a frame identical to the last is not painted at all. In a browser, [Live.Bind] wires a DOM element to all of it; see package backend/canvas. 

p.On(figure.Hover, func(ev figure.Event) {
    if ev.Found {
        tooltip(ev.Series(), ev.Hit.X, ev.Hit.Y)
    }
})

live, err := p.Live(canvas.Element(el))

Live data

data.Stream is a table a producer appends to from one goroutine while the renderer draws a frozen snapshot on another.

A chart as JSON

A Plot marshals to a Vega-Lite-shaped document and reads back as the same chart — see Plot.Spec, ParseJSON and package spec.

Status

Pre-alpha. Every release below v1.0.0 may contain breaking changes without a deprecation cycle. See CONCEPT.md for the design and the roadmap.

Index

Constants

View Source 
const (
	Hover = interact.Hover
	Leave = interact.Leave
	Click = interact.Click
	Zoom  = interact.Zoom
	Pan   = interact.Pan
	// Select is a region the reader dragged out. See [Live.Select].
	Select = interact.Select
)

The event kinds. See interact.EventKind.

View Source 
const (
	// Vertex is a point a layer drew. See [interact.Vertex].
	Vertex = interact.Vertex
	// Area is a filled shape. See [interact.Area].
	Area = interact.Area
	// Label is text a layer drew. See [interact.Label].
	Label = interact.Label
	// LegendRow is a row of the legend, which is furniture a reader can act
	// on. See [interact.LegendRow] and [Live.Toggle].
	//
	// It is spelled with the Row because [Legend] is already the option that
	// asks a plot for one.
	LegendRow = interact.LegendRow
	// Colorbar is a colourbar, or one band of a classed one. See
	// [interact.Colorbar].
	Colorbar = interact.Colorbar
	// SizeKey is a row of a size key. See [interact.SizeKey].
	SizeKey = interact.SizeKey
)

The mark kinds a hit can report. See interact.Kind.

View Source 
const DefaultClickSlop = 3

DefaultClickSlop is how far the pointer may travel between press and release and still count as a click rather than a drag, in device-independent pixels.

It is not zero because a pointer never is: a hand on a mouse moves a pixel or two during a click, and a finger on a trackpad more. Three pixels is the figure the desktop toolkits settled on, and it is well below the distance a deliberate pan covers.

View Source 
const DefaultDuration = 250 * time.Millisecond

DefaultDuration is how long a transition takes when nobody says. A quarter of a second is long enough to be followed by eye and short enough that a reader clicking through states is not waiting for the chart.

View Source 
const DefaultTrackSize = 48

DefaultTrackSize is the thickness of a track that was given none, in device-independent pixels. It is about three lanes' worth.

Variables

View Source 
var ErrEmptyGrid = errors.New("figure: grid has no plots")

ErrEmptyGrid reports a render of a grid with no plots in it.

View Source 
var ErrNoLayers = errors.New("figure: plot has no layers and no scales")

ErrNoLayers reports a render of a plot with nothing in it. Rendering empty axes is a legitimate thing to want, so this is only returned when there is also no scale configured — that combination is always a mistake.

View Source 
var ErrNoTweens = errors.New("figure: a transition needs at least one tween")

ErrNoTweens reports a transition with nothing to move.

View Source 
var ErrTrackWithFacet = errors.New("figure: a plot cannot have both a track and a facet")

ErrTrackWithFacet reports a plot that has both a track and a facet.

A facet owns the grid's rows and columns — it is what decides how many there are and what each one means — and a track needs a row of that grid to live in. A band spanning a facet is a different feature with different questions to answer, so this is refused rather than guessed at.

Functions

func EaseIn 

func EaseIn(f float64) float64

EaseIn starts slowly and arrives at speed. It is rarely what a chart wants: a movement that ends abruptly reads as an interruption rather than as an arrival.

func EaseInOut 

func EaseInOut(f float64) float64

EaseInOut starts slowly, moves, and settles. It is the default because it is the curve that reads as one movement rather than as a start and a stop.

func EaseLinear 

func EaseLinear(f float64) float64

EaseLinear is no easing at all: the fraction unchanged.

func EaseOut 

func EaseOut(f float64) float64

EaseOut leaves at speed and settles. It is what one thing moving to one new place wants.

func NewTable 

func NewTable() *data.Table

NewTable returns an empty table that can mix numeric and time columns. See data.NewTable.

func WheelFactor 

func WheelFactor(delta float64) float64

WheelFactor turns a raw scroll delta into a zoom factor.

The exponential keeps a fast scroll from inverting: any delta maps into (0, ∞) and never through zero, so holding the wheel down zooms smoothly rather than jumping. The rate is chosen so that one notch on a mouse — a hundred units in the browser's pixel mode — is about ten percent, which is the step a reader expects from a map.

Types

type Backend 

type Backend = ir.Backend

Backend is a renderer. See package ir.

type Brush 

type Brush struct {
	// Rect is the region, in device space. An empty one draws nothing.
	Rect ir.Rect
	// Fill and Stroke override the theme. A zero Fill takes the theme's axis
	// colour at a tenth opacity and a zero Stroke takes it at half.
	Fill   ir.Color
	Stroke ir.Color
	// Width is the outline's width. Zero takes one device unit.
	Width float32
}

Brush is the rectangle a reader is dragging out, drawn as feedback while they drag it.

It is the visible half of DragSelects and DragZooms: Input.Dragged reports the rectangle, and this draws it. The two are separate because a surface may want to draw its own, and because a selection means nothing until it is released.

The zero value draws nothing: an empty rectangle is not a selection.

func (*Brush) DrawOverlay 

func (br *Brush) DrawOverlay(b ir.Backend, f OverlayFrame)

DrawOverlay implements render.Overlay.

type Crosshair 

type Crosshair struct {
	// At is where the lines cross, in device space.
	At ir.Point
	// Show is whether to draw at all. A crosshair that is not shown draws
	// nothing — which changes the frame's call count and therefore makes that
	// one frame a full repaint. Moving one does not.
	Show bool

	// Panel is which panel to draw in, or -1 to use the one containing At.
	// It is a field rather than always inferred so that a chart linked to
	// another can put a crosshair in a panel the pointer is not in.
	Panel int

	// Color, Width and Dash override the theme. A zero Color takes the
	// theme's axis colour at half opacity, a zero Width takes one device
	// unit, and a nil Dash is the theme's grid dash.
	Color ir.Color
	Width float32
	Dash  []float32

	// Vertical and Horizontal turn each rule off. Both are drawn by default,
	// which is what "crosshair" means; a chart against a time axis often
	// wants only the vertical one.
	NoVertical   bool
	NoHorizontal bool
}

Crosshair is a pair of rules through a point, confined to the panel it is in.

It is the cheapest thing a reader can be given for "which value is this": two lines meeting where the pointer is, so that a point in the middle of a scatter can be read off both axes at once.

The zero value draws nothing. Set Crosshair.At and Crosshair.Show from a hover handler; the colours default to the chart's own axis colour, so a crosshair over a dark theme is legible without being told.

func (*Crosshair) DrawOverlay 

func (c *Crosshair) DrawOverlay(b ir.Backend, f OverlayFrame)

DrawOverlay implements render.Overlay.

type Drag 

type Drag uint8

Drag is what dragging the pointer across the chart does. 

const (
	// DragPans moves the view under the pointer, which is what a drag has
	// always done and what a reader of a map expects.
	DragPans Drag = iota
	// DragSelects drags out a rectangle and fires [Select] with the rows
	// under it on release. The view does not move.
	DragSelects
	// DragZooms drags out a rectangle and zooms to it on release, which is
	// the other thing a rubber band conventionally means.
	DragZooms
)

The drag modes.

func (Drag) String 

func (d Drag) String() string

String names the mode, for tests and error messages.

type Easing 

type Easing func(f float64) float64

Easing reshapes a fraction in [0, 1]. It is what makes a movement look like something starting and stopping rather than a thing dragged at a constant rate.

type Edge 

type Edge int

Edge names a side of the plot area. 

const (
	// Bottom puts the track below the panel. Several bottom tracks stack
	// downwards in the order they were added, and the last of them carries
	// the shared X axis.
	Bottom Edge = iota
	// Top puts the track above the panel, below the chart title. Several top
	// tracks stack upwards: the first added sits nearest the panel.
	Top
	// Left puts the track beside the panel, to its left. Several left tracks
	// stack leftwards — the first added sits nearest the panel — and the
	// outermost carries the shared Y axis.
	Left
	// Right puts the track beside the panel, to its right. Several right
	// tracks stack rightwards: the first added sits nearest the panel.
	Right
)

The edges a track can be attached to.

Which edge a track is on decides which of the plot's scales it shares. Bottom and Top are grid rows and share the plot's X; Left and Right are grid columns and share its Y. That is the same statement twice, turned a quarter turn: a track shares the axis it runs along, and brings its own for the one it is thick in.

func (Edge) String 

func (e Edge) String() string

String names the edge. It is what a spec document writes down.

type Event 

type Event = interact.Event

Event is one thing that happened to a chart. See interact.Event.

type EventKind 

type EventKind = interact.EventKind

EventKind is what happened. See interact.EventKind.

type Grid 

type Grid struct {
	// contains filtered or unexported fields
}

Grid renders several plots together in one image, with their axes aligned.

It is the other half of the multi-panel story: Plot.Facet splits one plot by a column, and a Grid puts different plots side by side. Both go through the same solver, so the panels line up either way. 

g := figure.NewGrid(2, figure.GridSize(900, 600), figure.GridTitle("Fleet"))
g.Add(latency, throughput, errors, saturation)
err := g.Render(figure.SVG("fleet.svg"))

A member plot contributes its layers, its scales and its title, which becomes the label above its panel. The canvas is the grid's: its size, theme, chart title and axis titles are the ones used, and a member plot's own size, theme and axis titles are not. That is the price of one image — two panels cannot disagree about the colour of the paper they are printed on.

func NewGrid 

func NewGrid(cols int, opts ...GridOption) *Grid

NewGrid creates a grid that flows plots into rows of cols panels.

func (*Grid) Add 

func (g *Grid) Add(ps ...*Plot) *Grid

Add appends plots, filling the grid left to right and wrapping.

func (*Grid) At 

func (g *Grid) At(row, col int, p *Plot) *Grid

At places a plot in a specific cell, replacing whatever was there. Cells left empty stay empty, which is how a grid is given a deliberate hole.

func (*Grid) Render 

func (g *Grid) Render(t Target) (err error)

Render draws the grid into t.

type GridOption 

type GridOption func(*Grid)

GridOption configures a Grid at construction.

func GridAxisTitles 

func GridAxisTitles(x, y string) GridOption

GridAxisTitles labels the shared axes, once for the grid. Panels keep their own scales; these name what those scales measure.

func GridColWidths 

func GridColWidths(w ...float32) GridOption

GridColWidths fixes the width of each column in device-independent pixels, as GridRowHeights does for rows. A zero entry, or a column past the end of the list, is left to the solver.

func GridDPR 

func GridDPR(r float64) GridOption

GridDPR sets the device pixel ratio. See DPR.

func GridDescription 

func GridDescription(title, detail string) GridOption

GridDescription attaches an accessible description to the grid. See Description.

There is no `Grid.Describe`: a grid is several charts, and the honest description of one is written by whoever knows why they are on the same page. The grid's title is carried into the output either way, as a chart's is.

func GridLegend 

func GridLegend(show bool) GridOption

GridLegend forces the legend on or off. By default it appears when any panel would have shown one.

func GridMath 

func GridMath(ts mathtext.Typesetter) GridOption

GridMath typesets the notation in the grid's labels — its title, its axis titles, and the title of every panel in it. See Math and package mathtext.

A member plot's own typesetter is not used, for the same reason its theme is not: the canvas is the grid's, and two panels cannot disagree about how a label is set.

func GridParallel 

func GridParallel(on bool) GridOption

GridParallel controls whether the panels are built concurrently. See Parallel; a grid is the shape that benefits most, because its panels are different charts over different data.

func GridRowHeights 

func GridRowHeights(h ...float32) GridOption

GridRowHeights fixes the height of each row in device-independent pixels. A zero entry, or a row past the end of the list, is left to the solver, and the rows left to it share what the fixed rows leave, equally.

It is what makes a grid of plots express the shape a track expresses inside one plot: a full-height plot with a short strip under it. 

figure.NewGrid(1, figure.GridRowHeights(0, 48), figure.GridSharedX(true))

func GridSharedX 

func GridSharedX(on bool) GridOption

GridSharedX writes the X tick labels only under the bottom row, instead of under every panel.

It is half of what stacked plots on one domain need; the other half is giving those plots the same scale.Scale object, which shares their domain, their nicing and — for a Live chart — their zoom, because a zoom reaches a scale and there is only one scale to reach: 

t := scale.Time()
speed := figure.New().X(t).Y(scale.Linear())
states := figure.New().X(t).Y(scale.Ordinal())

Turn it on only when the plots really do share a domain. Labels under one axis and different numbers on another is the misreading this exists to prevent, and enabling it cannot make two unrelated domains agree.

A Grid renders; it has no Plot.Live. Interaction on stacked plots is what a track inside one plot is for — see Plot.Track.

func GridSharedY 

func GridSharedY(on bool) GridOption

GridSharedY writes the Y tick labels only beside the first column, as GridSharedX does for the bottom row. The same caution applies: turn it on only when the plots in a row really do share a domain, which they do when they were given the same scale.Scale object.

func GridSize 

func GridSize(w, h int) GridOption

GridSize sets the output size in device-independent pixels. The default is 900x600, which is a grid's worth rather than a single chart's.

func GridTheme 

func GridTheme(t themepkg.Theme) GridOption

GridTheme sets the visual tokens for the whole grid.

func GridTitle 

func GridTitle(s string) GridOption

GridTitle sets the title above the grid.

type Highlight 

type Highlight struct {
	// At are the points to ring, in device space.
	At []ir.Point
	// Radius is the ring's radius in device units. Zero takes six, which is
	// a little larger than a default scatter marker.
	Radius float32
	// Color and Width override the theme. A zero Color takes the theme's
	// label colour and a zero Width takes two device units — a ring wants to
	// read as an annotation rather than as data.
	Color ir.Color
	Width float32
	// Panel confines the rings to one panel, or -1 to draw each in whichever
	// panel contains it. A point in no panel is not drawn.
	Panel int
}

Highlight rings a set of marks, to say "these ones".

It is what a chart linked to another draws: the first chart reports which row the pointer is on, the host finds where that row landed here with interact.Index.Locate, and this puts a ring round it. Nothing about the layer changes, so the highlight cannot disturb the reading.

The zero value draws nothing.

func (*Highlight) DrawOverlay 

func (h *Highlight) DrawOverlay(b ir.Backend, f OverlayFrame)

DrawOverlay implements render.Overlay.

type Hit 

type Hit = interact.Hit

Hit is the mark under a pointer. See interact.Hit.

type Input 

type Input struct {
	// contains filtered or unexported fields
}

Input turns a surface's raw pointer input into chart interaction.

Live takes deliberate instructions — hover here, zoom about there by this much, pan by that. A surface reports something rawer: a button went down, the pointer moved, the wheel turned by ninety-six of whatever units this platform counts in. The translation between the two is a small state machine — is this move a hover or a drag, was that release a click or the end of a pan — and it is the same state machine on every surface.

So it lives here, once, rather than being written again in every backend. [Live.Bind] is this driving a DOM element; a native window drives it from its own event loop; a test drives it directly. A backend consumes IR and must not know what a panel or a scale is, which is why none of this is in one. 

in := live.Input()
// from the surface's event loop:
in.Down(x, y)
in.Move(x, y)   // pans, because a button is down
in.Up(x, y)     // clicks, because the pointer barely moved
in.Wheel(x, y, deltaY)

An Input is not safe for concurrent use, and neither is the Live behind it.

func (*Input) ClickSlop 

func (i *Input) ClickSlop(px float64) *Input

ClickSlop sets how far the pointer may move between press and release and still count as a click. It returns i so the call can be chained.

func (*Input) DoubleClick 

func (i *Input) DoubleClick() error

DoubleClick resets the view, releasing every zoom and pan, and redraws. It is the one control a reader looks for first.

func (*Input) Down 

func (i *Input) Down(x, y float64) error

Down reports a button pressed at a device position. It starts a drag, which becomes a pan once the pointer has moved past the click slop.

func (*Input) Drag 

func (i *Input) Drag(d Drag) *Input

Drag sets what a drag does and returns i, so the call can be chained onto Live.Input.

It is a mode rather than a modifier key because a modifier is a fact about a keyboard and this package has never seen one: a browser reports shift on its own events, a window reports it on its own, and a touch screen has none at all. A surface that wants shift-to-select reads its own event and sets the mode; a surface that wants a toolbar button sets it from the button. Either way the state machine is the same one.

Changing it mid-drag takes effect on the next press, so a mode switched under a held button does not turn half a pan into half a selection.

A drag that *starts on a colourbar* ignores this and selects a range of values along the bar, whatever the mode says. There is no view to pan on a bar and no rectangle to zoom to, so a drag over one has exactly one sensible reading — see Live.Select and interact.Colorbar.

func (*Input) Dragged 

func (i *Input) Dragged() (ir.Rect, bool)

Dragged reports the rectangle a rubber-band drag currently covers, and whether there is one. A surface draws it as feedback; Input.Dragging is the same question without the geometry.

It is empty in DragPans, where a drag moves the chart rather than marking out part of it.

func (*Input) Dragging 

func (i *Input) Dragging() bool

Dragging reports whether a drag is in progress — a button is held and the pointer has moved past the click slop. A surface uses it to decide what cursor to show.

func (*Input) Leave 

func (i *Input) Leave() error

Leave reports the pointer leaving the surface. It cancels any drag in progress and fires Leave, so that a tooltip opened on a hover closes.

func (*Input) Live 

func (i *Input) Live() *Live

Live returns the chart this input drives.

func (*Input) Move 

func (i *Input) Move(x, y float64) error

Move reports the pointer at a device position.

With no button held it hovers, which fires Hover and reports the mark under the pointer. With a button held it pans, which drags the data under the pointer and redraws — so the value the reader grabbed stays under their finger, which is the whole reason a drag pans in the direction it does.

func (*Input) Rescale 

func (i *Input) Rescale(dpr float64) error

Rescale reports the surface's new device pixel ratio and redraws. See Live.Rescale.

func (*Input) Resize 

func (i *Input) Resize(w, h int) error

Resize reports the surface's new size and redraws. See Live.Resize.

func (*Input) Up 

func (i *Input) Up(x, y float64) error

Up reports the button released at a device position.

A release that never moved past the click slop is a click, and fires Click; one that did is the end of a pan and fires nothing, because every step of it has already fired Pan. That is what keeps a dragged chart from also selecting whatever the pointer happened to land on.

A release with no press behind it fires nothing either. A surface has more ways to lose a press than to report one — a double click consumed by Input.DoubleClick, a press that started outside the chart, a window that took the pointer away — and inventing a click for each of them would put a tooltip on screen every time a reader reset the view.

func (*Input) Wheel 

func (i *Input) Wheel(x, y, delta float64) error

Wheel zooms about a device position by a raw scroll delta, and redraws.

The delta is in the browser's pixel convention, which is the one every platform can be converted into: positive scrolls the content away from the reader and zooms out, and one notch of a mouse wheel is about a hundred. WheelFactor is the curve it goes through.

type Kind 

type Kind = interact.Kind

Kind is what sort of thing a hit landed on. See interact.Kind.

type Live 

type Live struct {
	// contains filtered or unexported fields
}

Live is a chart drawn into a surface that can be redrawn, pointed at, panned and zoomed.

It is the interactive half of a plot: Plot.Render draws once into a file, Live draws over and over into something that stays open — a browser canvas, a window, a test. 

live, err := p.Live(canvas.Element(el))
defer live.Close()
live.Draw()

// from the surface's event loop
live.Move(x, y)
live.Wheel(x, y, dy)

What a redraw costs

Each Draw records the frame, compares it with the last one and repaints only where the two differ — see ir.Damage. A backend that cannot repaint part of a frame gets the whole one, and a frame that is identical to the last is not painted at all.

The chart is built once

Live resolves the plot into panels when it is created, so that a zoom lands on scales that are still there next frame. Adding a layer, changing the facet or replacing a scale afterwards needs Live.Rebuild, which starts again from the plot as it now stands and puts the reader's view back onto the axes that survive.

Two kinds of method

Live.Move, Live.Click and Live.Leave return the Event they fired and no error, because they do not draw: a hover reads the index and reports. Live.Wheel, Live.PanBy, Live.ZoomTo and Live.Autoscale return an error and no event, because each changes the view and redraws it, and a redraw can fail. The split is the difference between asking the chart something and changing it.

A Live is not safe for concurrent use.

func (*Live) Autoscale 

func (l *Live) Autoscale() error

Autoscale releases every zoom and pan, so the axes come from the data again, and redraws. It is the "reset view" every interactive chart needs.

func (*Live) Click 

func (l *Live) Click(x, y float64) Event

Click reports a click at a device position and fires Click.

func (*Live) Close 

func (l *Live) Close() error

Close finalises the target. The last frame drawn is what it holds.

func (*Live) CurrentOverlay 

func (l *Live) CurrentOverlay() Overlay

CurrentOverlay reports what is painting over the chart, or nil.

func (*Live) DPR 

func (l *Live) DPR() float64

DPR reports the surface's current device pixel ratio.

func (*Live) Draw 

func (l *Live) Draw() error

Draw renders the current state of the plot.

It returns nil having painted nothing when the frame is identical to the last one, which is the common case for a pointer moving over a chart that is not being zoomed.

func (*Live) Hide 

func (l *Live) Hide(layer int, hide bool) error

Hide turns a layer off, or back on, and redraws.

A hidden layer is not drawn. It still trains its scales, and it still appears in the legend — dimmed, so that a reader can see what they have put away and bring it back.

The axes deliberately do not move. A toggle is a reading aid — let me see this one without that one on top — and an axis that rescaled every time one was clicked would make the two readings incomparable, which is the thing the toggle was for. A caller who wants the axes to follow what is left is making a different statement about the chart, and makes it with Plot.SetLayers and Live.Rebuild.

The index is redrawn with it, so a hidden layer's marks are no longer under the pointer: a tooltip for something invisible would be a tooltip for nothing.

A layer index outside the chart's layers is ignored and redraws nothing.

func (*Live) Index 

func (l *Live) Index() *interact.Index

Index returns the hit index of the last frame, for a caller drawing its own tooltip or crosshair.

func (*Live) Input 

func (l *Live) Input() *Input

Input returns a driver for this chart's surface input.

Each call returns a fresh driver with no button held. A surface wants one, made once and kept for as long as the Live is open.

func (*Live) IsHidden 

func (l *Live) IsHidden(layer int) bool

IsHidden reports whether a layer is currently turned off.

func (*Live) Leave 

func (l *Live) Leave() Event

Leave reports the pointer leaving the surface and fires Leave.

func (*Live) Move 

func (l *Live) Move(x, y float64) Event

Move reports the pointer at a device position and fires Hover.

The event carries the mark under the pointer, if there is one within interact.DefaultTolerance, and the panel the pointer is in, or -1 for a point in the margins.

The one move that fires something else is the move that leaves the last panel: that fires Leave instead, once, so that a tooltip opened on a hover has a matching event to close on. Moving around in the margins after that goes on firing Hover with no hit.

func (*Live) Overlay 

func (l *Live) Overlay(o Overlay) *Live

Overlay installs something to paint over the chart, and returns l so the call can be chained onto Plot.Live. Passing nil removes whatever was there.

It takes effect on the next Live.Draw. An overlay is a *pointer* to a struct whose fields the caller then moves — a crosshair's position, a tooltip's lines — so installing it once and mutating it per event is the intended shape, and there is nothing to re-install. 

cross := &figure.Crosshair{}
live.Overlay(cross)
p.On(figure.Hover, func(ev figure.Event) {
	cross.At, cross.Show = ev.Point, ev.Panel >= 0
})

A hover does not redraw by itself — Live.Move answers a question and does not change the chart — but Input.Move does when an overlay is installed, which is what makes the crosshair follow the pointer on a real surface. A frame identical to the last is still not painted, so a pointer moving over a chart with no overlay costs exactly what it did before.

func (*Live) PanBy 

func (l *Live) PanBy(dx, dy float64) error

PanBy moves the view by a device-space delta and redraws. It is what a drag does: the data follows the pointer, so dragging right shows earlier data.

func (*Live) Rebuild 

func (l *Live) Rebuild() error

Rebuild resolves the plot again, picking up layers, scales or a facet added since the Live was created, and keeps the view the reader had established.

Keeping the view is the whole point of the method rather than a courtesy. The thing a caller rebuilds for is usually a reaction to something the reader did — a hover in one chart that adds a highlight layer to this one — and throwing away their zoom as a side effect of answering them is a chart that fights back. Live.View and Live.SetView are the same capability spelled out, for a caller who wants it across something wider than a rebuild; a caller who genuinely wants a fresh start has Live.Autoscale.

A view can only be put back onto axes that exist. A facet whose free axes belonged to panels the new plot does not have loses those, because a domain from a panel that is gone describes nothing — and a rebuild that changes the panel count keeps nothing at all, for the same reason.

It does not paint. Restoring the view needs the new panels, and the panels are what a render announces, so this renders once into its own recording to find them — which draws nothing, and is why a rebuild costs a frame that nobody sees. The frame the reader sees is the caller's next Live.Draw.

func (*Live) Rescale 

func (l *Live) Rescale(dpr float64) error

Rescale tells the chart its surface's device pixel ratio has changed, and redraws it.

It is what a window dragged onto a display with a different one calls. The chart is not laid out differently — a device pixel ratio is not a size, and coordinates stay in device-independent units either way — but the surface behind it wants more pixels, and a backend that can provide them is told to. A backend that cannot is left alone and the frame is redrawn as it was.

Rescaling to the ratio it already has is not an error and draws nothing.

func (*Live) Resize 

func (l *Live) Resize(w, h int) error

Resize tells the chart its surface has changed size, and redraws it.

It is what a window's resize event and a reflowed canvas element call. The scales keep whatever they were zoomed or panned to — a reader who has dragged a view into place has not asked to leave it — and the chart is laid out again at the new size, so the margins, the tick count and the legend follow. A Responsive plot also rescales its type and stroke weights here.

The backend is told too, if it can be: a surface that implements ir.Resizer is resized in place rather than reopened, which is what keeps the frame on screen and the zoom in the scales. One that cannot is redrawn at the new logical size into the surface it has, which is the best available answer and is what a document target would do.

Resizing to the size it already has is not an error and draws nothing.

func (*Live) Select 

func (l *Live) Select(r ir.Rect) []Event

Select reports the rows under a device-space rectangle, firing one Select event per layer the rectangle touched.

It is the read half of a brush: the rectangle comes from wherever the caller got one — a drag through Input with Input.Drag set to DragSelects, a region computed from a value, a test — and what comes back is the rows, not a decision about them. What a selection *means* is the caller's: highlight them here, filter another chart by them, put them in a table beside the plot. figure does not remember which rows are selected, because a library that did would have to answer whose selection it was when two charts disagreed.

The events are returned as well as fired, so a caller driving this directly need not register a handler to see the answer. They come in layer order within a panel, and panel order across the chart.

It reports nothing without row tracking — see Live.TrackRows. A rectangle over marks whose rows are unknown is a rectangle over an unanswered question, and reporting the marks instead would be answering a different one. It does not draw: like Live.Move and Live.Click, asking the chart something does not change it.

func (*Live) SetView 

func (l *Live) SetView(v View) error

SetView puts a view back and redraws.

It is the counterpart of Live.View and the two are meant to bracket something that would otherwise lose the reader's place. A view of a different shape — taken from a chart with a different number of panels — is ignored rather than applied partly, and an empty view does nothing; both return nil and redraw, because "the view did not change" is not a failure.

An axis that cannot be pinned is left alone. scale.Zoomer is what a scale implements to have its domain set, and a scale that does not is a scale that does not zoom either — so there was nothing for a reader to establish and nothing to put back.

func (*Live) ShowAll 

func (l *Live) ShowAll() error

ShowAll turns every layer back on and redraws. It is what a "reset" control calls, and what Input.DoubleClick would call if hiding were a view state — it is not, because a hidden series is a statement about what the reader wants to see rather than about where they are looking.

func (*Live) Size 

func (l *Live) Size() (w, h int)

Size reports the surface's current size in device-independent pixels.

func (*Live) Toggle 

func (l *Live) Toggle(layer int) error

Toggle turns a layer off if it is on, and on if it is off, and redraws.

It is what a click on a legend row calls: 

p.On(figure.Click, func(ev figure.Event) {
	if ev.Hit.Kind == figure.LegendRow {
		live.Toggle(ev.Hit.Layer)
	}
})

That the wiring is four lines in the caller rather than a mode on the chart is deliberate, and is the same answer this library gives everywhere a pointer means something: figure says what was clicked, and what it means is the program's. A legend that always toggled would be wrong for a chart whose legend selects rather than filters, or one where clicking a series should open something.

A Colorbar or a SizeKey hit has no Toggle: neither stands for a layer, so what a click on one means is a range of values or a magnitude rather than a series to put away. See [Hit.Lo], [Hit.Hi] and [Hit.Value].

func (*Live) TrackRows 

func (l *Live) TrackRows(on bool) *Live

TrackRows turns row identity on or off and returns l, so the call can be chained onto Plot.Live. 

live, err := p.Live(canvas.Element(el))
live.TrackRows(true)
// ...
p.On(figure.Hover, func(ev figure.Event) {
    if ev.Found && ev.Hit.Row >= 0 {
        highlightTableRow(ev.Hit.Row)
    }
})

It is off by default because it is not free. With it on, every layer that can report its rows records where each one landed, and the hit index keeps a position and a row number per mark on top of the marks it already keeps — memory proportional to the marks on screen, which after decimation is thousands rather than millions, but not nothing. Without it, [Hit.Row] is -1 and a hit still reports the data values under the pointer.

It takes effect on the next Live.Draw.

Not every mark has a row to report. A boxplot's box aggregates many rows, a density raster is not a mark at all, an interpolated point across a gap was never measured, and a third-party geom that does not report its rows has none to report; all of those leave [Hit.Row] at -1 rather than guessing a nearby one.

func (*Live) Transition 

func (l *Live) Transition(tweens ...*data.Tween) (*Transition, error)

Transition prepares a move between the state its tweens start at and the state they end at.

It positions the tweens at the start and draws nothing: the first frame is the caller's first Transition.At or Transition.Advance.

func (*Live) View 

func (l *Live) View() View

View reports where the chart is currently looking.

It is taken from the frame last drawn: the panels and their scales are what the render announced, so a View from a chart that has not been drawn is empty. Every axis is read, including the secondary ones, because a view that restored one direction and not the other would slide two series apart — which is the same reason Live.Wheel moves all four.

func (*Live) Wheel 

func (l *Live) Wheel(x, y, factor float64) error

Wheel zooms about a device position by factor, and redraws.

factor below 1 zooms in and above 1 zooms out: it multiplies the width of the view, so 0.8 shows four fifths of what was there. A wheel notch is usually turned into 0.9 or 1.1 by the surface.

Both axes zoom, about the pointer, so that the value under the cursor stays under the cursor. A scale that cannot be zoomed — an ordinal axis, where half a category is not a view of anything — is left alone, and a wheel over a chart with two such axes does nothing at all.

func (*Live) ZoomTo 

func (l *Live) ZoomTo(r ir.Rect) error

ZoomTo zooms into a device-space rectangle — a rubber-band selection — and redraws.

type Option 

type Option func(*Plot)

Option configures a Plot at construction.

func Coord 

func Coord(c coordpkg.Coord) Option

Coord sets the coordinate system: what the interval a scale maps into means.

The default is [coord.Cartesian], the identity, where the interval is a distance along an edge of the plot. [coord.Polar] wraps one axis around a circle and reads the other as a radius, which is all a pie, a donut, a radar, a rose or a gauge is — the marks are the ones that were already there: 

p := figure.New(figure.Coord(coord.Donut(0.45)))
p.X(scale.Linear())
p.Y(scale.Linear())
p.Add(geom.Bar(src, geom.X("one"), geom.Y("share"), geom.GroupBy("browser")))

[coord.Pie] and [coord.Donut] are that recipe named; neither scale is niced, because a pie's ring closes on the stacked total. A slice can also name its own inner and outer radius with geom.X and geom.X2 and be broken out of the ring with geom.ExplodeBy, neither of which is a new mark.

[coord.Smith] is the third one, and the same idea over a different map: it reads the pair as a normalised impedance and carries it through Γ = (z − 1)/(z + 1) onto the unit disc, which is the Smith chart. Its grid is the two axes' own ticks — a circle per resistance, an arc per reactance — so again the mark is one that was already there: 

p := figure.New(figure.Coord(coord.Smith()))
p.X(scale.Linear(scale.Domain(0, 50), scale.TickValues(0, 0.2, 0.5, 1, 2, 5)))
p.Y(scale.Linear(scale.Domain(-50, 50), scale.TickValues(-5, -1, -0.5, 0.5, 1, 5)))
p.Add(geom.Line(sweep, geom.X("r"), geom.Y("x")))

A coord belongs to the chart rather than to a panel, so the panels of a facet all share it.

func DPR 

func DPR(r float64) Option

DPR sets the device pixel ratio. Backends that rasterize multiply the pixel buffer by it; coordinates stay in device-independent units either way. The default is 1.

func Description 

func Description(title, detail string) Option

Description attaches an accessible description to the chart.

title is the short label — an SVG's <title>, a PDF's document title, a canvas element's aria-label. detail is the long reading, which an SVG puts in a <desc> and a screen reader reads after the title. Either may be empty.

A chart with a Title already has a short label and needs no option to get one: the title is written into the output as a matter of course, because a picture with no accessible name is the one thing every accessibility guideline agrees about. This option is for saying something *other* than the title, and for the paragraph a title cannot hold.

Plot.Describe writes both from the data instead, which is what to reach for when the chart is built by a program rather than by a person.

func Legend 

func Legend(show bool) Option

Legend forces the legend on or off. By default a legend appears once a plot has more than one layer: one series does not need to be told apart from anything.

func Locale 

func Locale(l *scale.Locale) Option

Locale sets the language every axis of this plot writes its tick labels in: the decimal and group separators of a number, the percent sign, and the month and weekday names of a time axis.

It reaches the scales through scale.Localizer, which every scale in the scale package implements except the ordinal one — an ordinal axis labels its ticks with the caller's own categories, and translating those would be inventing data. A scale from somewhere else that does not implement it is left alone rather than refused.

It is a plot option rather than a scale one because a chart is in one language: setting it per scale means saying it once per axis and once per track, and forgetting it somewhere is a chart with two languages in it.

The default is scale.English, which is what every chart drew before this option existed. 

p := figure.New(figure.Locale(scale.LocaleDE))
p.X(scale.Time()).Y(scale.Linear(scale.NumberFormat("#,.1")))
// → "1.234,5" on the Y axis and "Mär 2026" on the X one

func Math 

func Math(ts mathtext.Typesetter) Option

Math typesets the notation in the chart's labels.

It applies to every label the chart draws — the title, the axis titles, the tick labels, the legend, a facet's strip, a geom's own note — because a typesetter is installed by wrapping the backend rather than by being consulted at each place text is written. 

p := figure.New(
    figure.Math(mathtext.TeX()),
    figure.YTitle(`flux density $F_\nu$ ($\mathrm{W\,m^{-2}\,Hz^{-1}}$)`),
)

Passing nil turns it off, which is the default: a chart with no typesetter draws its labels exactly as they were written, and pays nothing for the notation it does not have. See package mathtext.

func Parallel 

func Parallel(on bool) Option

Parallel controls whether a multi-panel chart builds its panels concurrently. It is on by default and produces identical output either way: each panel is recorded on its own goroutine and the recordings are replayed in panel order.

Turn it off to keep a render on one goroutine — inside a benchmark that is measuring something else, or in a process that has already committed its cores elsewhere. It has no effect on a chart with a single panel, which has nothing to overlap.

func Responsive 

func Responsive(on bool) Option

Responsive scales the theme with the size the chart is drawn at.

A plot is designed at one size — the one Size gave it, or the default 800x500 — and a responsive one keeps its proportions when it is drawn at another: half the width and half the height means half-size type, half-width strokes, half the margins. Without it a chart shrunk to a third of its design size keeps 12pt labels, and they eat the plot area.

It matters for a window, which the reader resizes, and for a browser canvas in a fluid layout. It does nothing at all to a chart rendered once at the size it was built with — the factor is exactly 1 — so turning it on cannot change an existing still.

The factor is the smaller of the two ratios, so that a chart stretched wide scales to what still fits its height, and it is clamped to the range a chart stays legible over. Colours do not scale; see theme.Scaled for what does.

func ResponsiveFrom 

func ResponsiveFrom(w, h int) Option

ResponsiveFrom is Responsive with the design size given explicitly rather than taken from Size.

It is what a still rendered at another size needs: a thumbnail of a chart designed at 800x500 is `Size(200, 125)` with `ResponsiveFrom(800, 500)`, and it comes out as the chart at a quarter of the size rather than as the chart with four times the type in it. A Live surface needs neither, because the size it was built with is already the design.

func Size 

func Size(w, h int) Option

Size sets the output size in device-independent pixels. The default is 800x500.

func Theme 

func Theme(t themepkg.Theme) Option

Theme sets the visual tokens. The default is theme.Light.

func Title 

func Title(s string) Option

Title sets the chart title.

func X2Title 

func X2Title(s string) Option

X2Title sets the title of the secondary horizontal axis, written along the chart's top. It is ignored by a chart with no Plot.X2.

func XTitle 

func XTitle(s string) Option

XTitle sets the horizontal axis title.

func Y2Title 

func Y2Title(s string) Option

Y2Title sets the title of the secondary vertical axis, written down the chart's right-hand side. It is ignored by a chart with no Plot.Y2.

func YTitle 

func YTitle(s string) Option

YTitle sets the vertical axis title.

type Overlay 

type Overlay = render.Overlay

Overlay paints over a finished chart. See render.Overlay.

type OverlayFrame 

type OverlayFrame = render.OverlayFrame

OverlayFrame is what an overlay is told. See render.OverlayFrame.

type OverlayPanel 

type OverlayPanel = render.OverlayPanel

OverlayPanel is one panel of that frame. See render.OverlayPanel.

type Overlays 

type Overlays []Overlay

Overlays draws several overlays in order, so that a chart can have a crosshair and a tooltip at once.

The order is the drawing order: later ones are on top, which is why a tooltip belongs after a crosshair rather than before it. A nil member is skipped, so a caller may keep a fixed-length list and switch one off by clearing it.

func (Overlays) DrawOverlay 

func (os Overlays) DrawOverlay(b ir.Backend, f OverlayFrame)

DrawOverlay implements render.Overlay.

type Plot 

type Plot struct {
	// contains filtered or unexported fields
}

Plot is a chart specification: size, theme, scales and layers.

A Plot is not safe for concurrent modification. Rendering the same Plot twice is supported and produces the same result, provided the underlying data has not changed.

func FromSpec 

func FromSpec(s spec.Spec) (*Plot, error)

FromSpec builds a plot from a document.

func New 

func New(opts ...Option) *Plot

New creates a Plot.

func ParseJSON 

func ParseJSON(b []byte) (*Plot, error)

ParseJSON builds a plot from a spec document. 

p, err := figure.ParseJSON(b)
if err == nil {
    err = p.Render(figure.SVG("chart.svg"))
}

It is the whole web workflow in two calls: a browser or a config file hands over a chart, and the same model that a Go program builds by hand draws it.

func (*Plot) Add 

func (p *Plot) Add(gs ...geom.Geom) *Plot

Add appends layers, drawn in the order given.

func (*Plot) DataTable 

func (p *Plot) DataTable(w io.Writer) error

DataTable writes the chart's data to w as an HTML table — the fallback for a reader who cannot see the picture, and the honest answer to what is in it. See a11y.WriteTable.

func (*Plot) Describe 

func (p *Plot) Describe() a11y.Summary

Describe reads the chart's own data and attaches a description of it, then returns what it wrote. See a11y.Describe for the shape of the summary and a11y.Chart for what it is derived from. 

p.Describe()
p.Render(figure.SVG("chart.svg")) // carries <title> and <desc>

It is a method that does work rather than an option that sets a flag, because the work is a pass over every plotted column: a chart that nobody asked to describe should not pay for one on every render, and a chart that did should pay for it once rather than per frame. Call it again after the data changes.

A description written by Description is replaced by this, and calling Describe on a plot that has been given one is how a caller says the data has moved on.

func (*Plot) Description 

func (p *Plot) Description() ir.Description

Description reports the description the chart currently carries: the one Description or Plot.Describe set, or the chart's title alone.

func (*Plot) Facet 

func (p *Plot) Facet(s *facet.Spec) *Plot

Facet splits the plot into small multiples, one panel per value of a column. See facet.Wrap and facet.Grid. 

p.Facet(facet.Wrap("region", facet.Columns(3)))

Passing nil turns faceting back off.

func (*Plot) HideLayer 

func (p *Plot) HideLayer(layer int, hide bool) *Plot

HideLayer turns a layer off, or back on, by its index among the plot's layers. A hidden layer is not drawn, still trains its scales, and still appears in the legend, dimmed.

It is on the plot as well as on Live for the reason Plot.Overlay is: otherwise Plot.Render and Live.Draw would disagree about what a chart is, and exporting a chart with a series put away would be impossible from the model alone. Live.Hide is the one a legend click calls, and it starts from whatever the plot said.

An index outside the plot's layers is ignored.

func (*Plot) Layers 

func (p *Plot) Layers() []geom.Geom

Layers reports the plot's layers, in drawing order. The slice is a copy; the layers in it are not.

It is what a caller reaching for Plot.SetLayers needs first: keeping the ones that were there and replacing the rest means being able to see them.

func (*Plot) Live 

func (p *Plot) Live(t Target) (*Live, error)

Live opens t and returns a chart drawn into it.

The target stays open until Live.Close, which is what makes this different from Plot.Render: a Live draws frame after frame into one surface.

It wants a surface rather than a document. The SVG and PDF emitters build a document and write it whole, so drawing many frames into one collects every frame in the same file rather than replacing what was there — use Plot.Render for those, and a Live for a canvas, a window, or anything else that is repainted. A single Draw into a document target is exactly a Render, and is a reasonable way to export what an interactive chart currently shows.

func (*Plot) MarshalJSON 

func (p *Plot) MarshalJSON() ([]byte, error)

MarshalJSON writes the plot as a spec document, so that a Plot can be handed straight to encoding/json.

Called directly it returns the indented form spec.Spec.Marshal produces: a chart is a thing people read and edit, and the compact form of one over a hundred rows is a single very long line. Called through json.Marshal it comes back compact, because that is what json.Marshal does to anything a Marshaler returns.

func (*Plot) On 

func (p *Plot) On(kind EventKind, h func(Event)) *Plot

On registers a handler for an event kind. 

p.On(figure.Hover, func(ev figure.Event) {
    if ev.Found {
        tooltip(ev.Series(), ev.Hit.X, ev.Hit.Y)
    }
})
p.On(figure.Zoom, func(ev figure.Event) { log.Println(ev.Rect) })

Handlers fire in registration order, from Live's input methods, on the goroutine that called one. Registering a handler does not by itself make a chart interactive — Plot.Live is what draws one into a surface that can report input.

func (*Plot) Overlay 

func (p *Plot) Overlay(o Overlay) *Plot

Overlay installs something to paint over the finished chart — a crosshair, a tooltip, a brush rectangle. Passing nil removes it. See Overlay.

It is on the plot as well as on Live so that the two agree about what a chart is: an overlay that only existed on a live surface would make Plot.Render and Live.Draw draw different pictures of the same model, and exporting what a reader is looking at — the chart with its crosshair where they left it — would be impossible from the model alone.

Live.Overlay overrides this for one surface. A plot that names one and a Live that names another draws the Live's, because the Live is the thing with a pointer over it.

func (*Plot) Render 

func (p *Plot) Render(t Target) (err error)

Render draws the plot into t.

It opens the target, lowers the chart into the backend it returns, flushes, and closes the target — so a file target has a complete file on disk when Render returns nil.

func (*Plot) SetLayers 

func (p *Plot) SetLayers(gs ...geom.Geom) *Plot

SetLayers replaces the plot's layers with the ones given, drawn in the order given. Passing none leaves a plot with no layers, which Plot.Render refuses with ErrNoLayers.

It is Plot.Add's counterpart and exists for the same caller: one reacting to something the reader did. A chart that gains a highlight layer on every hover and can never lose one accumulates a layer per pointer move, so a plot that can be added to has to be a plot that can be set. Building a fresh Plot each time is the alternative and a worse one — it discards the scales, and with them the zoom the reader established.

Layers already drawn are unaffected until the chart is resolved again: Live.Rebuild is what picks this up, and it keeps the view.

The slice is copied, so the caller may reuse it.

func (*Plot) Size 

func (p *Plot) Size() (w, h int)

Size reports the size the plot is drawn at, in device-independent pixels. It is what Size set, or the default, and it is what a surface opening a window for this plot wants to know.

func (*Plot) Spec 

func (p *Plot) Spec() (spec.Spec, error)

Spec writes the plot down as a document that can be marshalled to JSON and read back with FromSpec.

It fails on a layer or a scale that cannot describe itself rather than writing a document that draws a different chart — see github.com/timzifer/figure/spec for what survives the trip and what cannot.

func (*Plot) Track 

func (p *Plot) Track(e Edge, opts ...TrackOption) *Track

Track attaches a band to an edge of the plot area and returns it, so that layers can be added to it. 

p.Track(figure.Bottom, figure.TrackSize(48)).Add(states)

Tracks at one edge stack in the order they were added, outwards from the panel. Bands on two edges at once are fine — a strip below and a key beside leave the corner between them empty — and a track with a Plot.Facet is ErrTrackWithFacet: a facet already owns the grid the track would need a row or a column of.

func (*Plot) Tracks 

func (p *Plot) Tracks() []*Track

Tracks reports the tracks attached to the plot, in the order they were added. It is what a caller rebuilding a plot from another one needs.

func (*Plot) UnmarshalJSON 

func (p *Plot) UnmarshalJSON(b []byte) error

UnmarshalJSON replaces the plot's contents with the document in b.

func (*Plot) X 

func (p *Plot) X(s scale.Scale) *Plot

X sets the horizontal scale. The default is scale.Linear with nicing.

func (*Plot) X2 

func (p *Plot) X2(s scale.Scale) *Plot

X2 sets the chart's secondary horizontal axis: a second scale, drawn along the top, read by the layers that asked for it with geom.OnX2.

It is Plot.Y2 turned a quarter turn and everything said there holds, including that the second axis draws no grid lines. What it is *for* is different: two series measured over different extents of the same thing — a run indexed by cycle beside one indexed by elapsed time, a spectrum read in wavelength against the same spectrum in wavenumber, a backlog by date against a backlog by sprint.

The two directions are independent. A layer may name geom.OnX2 and geom.OnY2 together, and then it reads the top axis and the right one.

func (*Plot) Y 

func (p *Plot) Y(s scale.Scale) *Plot

Y sets the vertical scale. The default is scale.Linear with nicing.

func (*Plot) Y2 

func (p *Plot) Y2(s scale.Scale) *Plot

Y2 sets the chart's secondary vertical axis: a second scale, drawn down the right-hand side, read by the layers that asked for it with geom.OnY2.

It is the chart of two quantities in different units — revenue as bars against the left axis, margin as a percentage line against the right — and it is one chart with two axes rather than two charts overlaid, which is why the binding is on the layer and the scale is on the plot.

The second axis draws **no grid lines**. Two ladders of horizontal rules at different values are a moiré rather than a reading, and which of the two a line belongs to is unanswerable by looking; the grid stays the primary axis's. See [ADR 0037](docs/adr/0037-secondary-axis.md).

A chart with no layer on it draws the axis anyway, because an axis somebody asked for is a statement about the chart even where nothing reaches it yet — a live chart whose second series has not arrived is the case.

type RowRef 

type RowRef = interact.RowRef

RowRef is where one source row landed. See interact.RowRef.

type Source 

type Source = data.Source

Source is a columnar data source. See package data.

func Float64Columns 

func Float64Columns(cols map[string][]float64) Source

Float64Columns builds a Source over numeric columns, borrowing the slices. See data.Float64Columns.

type Target 

type Target = ir.Target

Target is a render destination. See package ir.

func PDF 

func PDF(path string, opts ...pdf.Option) Target

PDF returns a target writing a PDF document to the named file.

Like SVG, this is a zero-dependency path: the emitter is in backend/pdf and uses nothing but the standard library. The page is one PDF point per device-independent pixel, so a chart sized 800x500 is an 800x500pt page.

func PDFWriter 

func PDFWriter(w io.Writer, opts ...pdf.Option) Target

PDFWriter returns a target writing a PDF document to w.

func SVG 

func SVG(path string, opts ...svg.Option) Target

SVG returns a target writing an SVG document to the named file.

This is the zero-dependency path: it uses the built-in emitter in backend/svg and links no rendering engine.

func SVGWriter 

func SVGWriter(w io.Writer, opts ...svg.Option) Target

SVGWriter returns a target writing an SVG document to w.

type Tooltip 

type Tooltip struct {
	// At is the point the tooltip is about, in device space. The box is
	// placed beside it, not over it.
	At ir.Point
	// Lines are the text, one line each. No lines is no tooltip.
	Lines []string

	// Fill, Stroke and Color override the theme. A zero Fill takes the
	// theme's canvas background, a zero Stroke its axis colour, and a zero
	// Color its label colour — so a tooltip over a dark chart is dark.
	Fill   ir.Color
	Stroke ir.Color
	Color  ir.Color

	// Size is the type size in device units. Zero takes the theme's tick
	// size, which is the size the chart's other small text is set in.
	Size float64
	// Pad is the space between the text and the box. Zero takes six.
	Pad float32
	// Offset is how far the box sits from At. Zero takes twelve, which clears
	// a default marker and a fingertip.
	Offset float32
}

Tooltip is a box of text beside a point.

It is the one overlay that measures: the box is sized to the lines it holds, through the backend that is going to draw them, so a tooltip is the width of its text in the font it is actually rendered in rather than in an estimate of one.

It keeps itself on the canvas. A tooltip near the right edge flips to the left of its anchor and one near the bottom flips above it, because a box that ran off the drawing would hide the thing it was explaining.

The zero value draws nothing.

func (*Tooltip) DrawOverlay 

func (t *Tooltip) DrawOverlay(b ir.Backend, f OverlayFrame)

DrawOverlay implements render.Overlay.

type Track 

type Track struct {
	// contains filtered or unexported fields
}

Track is a band at an edge of the plot area, on one of the plot's own scales.

It is what a chart needs when part of what it shows is not on the panel's other axis at all: a gantt strip of machine states under a speed trace, a rug of event times, a ribbon of shifts, a key or a marginal distribution beside the panel. The track shares the axis it runs along — the same scale object, so a zoom is one zoom rather than two that agree — and carries a scale of its own across it, of whatever kind suits it. Putting an ordinal band under a linear panel is the case this exists for. 

p := figure.New()
p.X(scale.Time()).Y(scale.Linear())
p.Add(geom.Line(src, geom.X("t"), geom.Y("speed")))

p.Track(figure.Bottom, figure.TrackSize(48)).
	Add(geom.Rect(states, geom.X("start"), geom.X2("end"), geom.Y("row"),
		geom.ColorBy("state", palette)))

A track's size comes out of the panel, not out of the panel's domain: the axis the track does not share is identical with the track and without it. That is the difference between a track and the lane of negative values it replaces, where the lane was in the domain and `scale.Zero` stopped meaning what it said.

The axis it *does* share is trained by both, because it is one axis and not two that agree — a rug of event times widens the time axis to cover the events, which is the whole reason to draw them against it.

func (*Track) Add 

func (t *Track) Add(gs ...geom.Geom) *Track

Add appends layers to the track, drawn in the order given.

func (*Track) Edge 

func (t *Track) Edge() Edge

Edge reports which side of the panel the track is attached to.

type TrackOption 

type TrackOption func(*Track)

TrackOption configures a track.

func TrackAxis 

func TrackAxis(show bool) TrackOption

TrackAxis decides whether the track writes the tick labels of its own scale — the lane names, on an ordinal one. The default is true: a lane nobody can name is a coloured stripe.

They are written along the same edge the panel's are, and share the panel's gutter there, which is what keeps a track's edge and the panel's edge in the same place.

func TrackFraction 

func TrackFraction(f float32) TrackOption

TrackFraction sets the band's thickness as a share of the canvas, in (0, 1) — of its height for a Bottom or Top track, of its width for a Left or Right one. It is what a Responsive chart wants: a strip given 48 pixels keeps them as the canvas shrinks around it, and eventually there is nothing left to keep them out of.

It replaces any TrackSize.

func TrackGrid 

func TrackGrid(show bool) TrackOption

TrackGrid decides whether the track draws grid lines. The default is false: a grid line through a gantt bar is a rule drawn across a solid shape.

func TrackScale 

func TrackScale(s scale.Scale) TrackOption

TrackScale sets the track's own scale: the one it does not share. That is the vertical scale of a Bottom or Top track and the horizontal scale of a Left or Right one — in both cases the axis the band is thick in.

The default is scale.Ordinal, because a track's rows are usually lanes with names rather than a quantity. The scale is the track's alone: nothing here touches the scale the track shares with the panel.

func TrackSize 

func TrackSize(px float32) TrackOption

TrackSize sets how thick the band is, in device-independent pixels: the height of a Bottom or Top track, the width of a Left or Right one. It is the unit a lane count is naturally counted in — three lanes of sixteen pixels — and it is taken out of the panel, so the panel is what shrinks.

It replaces any TrackFraction. The default is DefaultTrackSize.

type Transition 

type Transition struct {
	// contains filtered or unexported fields
}

Transition moves a chart from where its tweens start to where they end.

figure owns no clock

Transition.At is the whole primitive: a fraction in, a frame out. It reads no clock, starts no goroutine and schedules nothing — which is what makes a transition a pure function of a number, and therefore something a golden file can be taken of. Transition.Advance is sugar for a host that has a time.Time to hand over.

The loop belongs to whatever is already running one: 

// A browser, from requestAnimationFrame:
running, err := tr.Advance(time.Now())

// A window, from window.Handler.Frame — asking for another frame only
// while it is running, so an idle window stays idle:
if running {
	w.Redraw()
}

// A test, with no clock at all:
tr.At(0.5)

The chart is not rebuilt

A data.Tween is one Source whose contents change, so the layer over it is built once and a frame of a transition costs a frame. Build the layers over data.Tween.Source before opening the Live, and hand the same tweens here.

The axes stay where they are

By default a transition moves the data and leaves the axes alone, because an axis that rescales itself every frame is one a reader cannot compare two frames of — the same reason a live chart pins its axes. A chart whose two states need different axes says so with Transition.Rescale.

A Transition is not safe for concurrent use, and neither is the Live behind it.

func (*Transition) Advance 

func (tr *Transition) Advance(now time.Time) (running bool, err error)

Advance puts the transition where the clock says it should be and redraws, reporting whether there is more to come.

The first call starts it, so a transition begins when the host first asks about it rather than when it was built — which is what lets one be prepared on a click and driven from the next frame callback.

running is false on the frame that reaches the end and on every call after it, so a host asking for another frame only while it is true stops asking exactly once.

func (*Transition) At 

func (tr *Transition) At(f float64) error

At puts the transition at a fraction of the way through and redraws.

The fraction is clamped to [0, 1] and goes through the easing curve. It is the primitive: everything else here is a way of choosing a number to give it.

func (*Transition) Done 

func (tr *Transition) Done() bool

Done reports whether the transition has reached its end.

func (*Transition) Ease 

func (tr *Transition) Ease(e Easing) *Transition

Ease sets the curve the fraction goes through and returns tr, so the call can be chained onto Live.Transition. The default is EaseInOut.

func (*Transition) Finish 

func (tr *Transition) Finish() error

Finish jumps to the end.

With Transition.Rescale on it also releases the axes, so that the chart goes back to following its data rather than staying pinned to wherever the transition left it. An axis left pinned is one that has quietly stopped tracking what it describes, which is a bug that shows up an hour later.

func (*Transition) Fraction 

func (tr *Transition) Fraction() float64

Fraction reports how far through the transition is, before easing.

func (*Transition) Over 

func (tr *Transition) Over(d time.Duration) *Transition

Over sets how long the transition takes and returns tr. It is read only by Transition.Advance; Transition.At does not know about time. The default is DefaultDuration.

func (*Transition) Rescale 

func (tr *Transition) Rescale(on bool) *Transition

Rescale makes the axes move with the data, and returns tr.

It is off by default: an axis that rescales itself every frame is one a reader cannot compare two frames of, and a chart whose two states share an axis should keep it. Turn it on when they genuinely do not — a transition from last week's range to this year's — and the domains slide between the two rather than jumping at the first frame.

It works by finding out where each axis ends up: the tweens are put at each end and the chart rendered into a recording nobody sees, twice, here rather than per frame. Between the two the axes are released, so **an axis with a domain fixed at construction loses it** — which is the point, because a fixed domain is a caller saying the axis does not move and this is a caller saying it does. Pass false to change one's mind before the first frame.

While it is on the domains are pinned, and pinning is doing a second job: a scale.Nice axis re-rounds whatever it is trained on, so an unpinned one would relabel itself mid-move — and a changed tick *count* is a structural change, which makes ir.Damage report the two frames as not comparable and turns every frame into a full repaint. The animation would be the slowest one available and would look exactly right. Transition.Finish releases them again.

type View 

type View struct {
	// contains filtered or unexported fields
}

View is where a chart is looking: the domain of every panel axis of the frame currently drawn.

It is the zoom and the pan a reader has established, in a form a caller can hold on to and put back. Live.Rebuild uses it to keep the view across a change to the plot, and a caller wanting the same guarantee across something wider — swapping a data source, rebuilding a dashboard — reaches for Live.View and Live.SetView directly.

A View is a value: taking one copies the numbers out of the scales, so it stays true after the scales move on. It describes the chart it was taken from and nothing else — put one back into a chart with a different number of panels and it is ignored, because a domain from the third panel of a grid of nine means nothing in a chart with one.

func (View) Empty 

func (v View) Empty() bool

Empty reports whether the view describes nothing — which is what Live.View returns from a chart that has not been drawn, because the panels are known from the render rather than from the plot.

func (View) Panels 

func (v View) Panels() int

Panels reports how many panels the view describes.

Source Files

View all Source files

Directories

Path Synopsis
Package a11y makes a chart readable by something other than an eye.
 Package a11y makes a chart readable by something other than an eye.
arrow module
backend
canvas
Package canvas draws a chart into a browser canvas.
 Package canvas draws a chart into a browser canvas.
pdf
Package pdf renders a chart to PDF using nothing but the standard library.
 Package pdf renders a chart to PDF using nothing but the standard library.
svg
Package svg is figure's built-in, zero-dependency SVG backend.
 Package svg is figure's built-in, zero-dependency SVG backend.
gg module
gg/gpu module
Package coord maps scaled positions into device space.
 Package coord maps scaled positions into device space.
Package data is figure's data layer: columnar, batch-oriented access to a table of values.
 Package data is figure's data layer: columnar, batch-oriented access to a table of values.
examples
accessible command
Command accessible renders a chart that can be read without being seen.
 Command accessible renders a chart that can be read without being seen.
bigdata command
Command bigdata renders two charts that could not be drawn mark for mark.
 Command bigdata renders two charts that could not be drawn mark for mark.
cascade command
Command cascade renders the chart ADR 0058 says decides whether the machinery pays for itself.
 Command cascade renders the chart ADR 0058 says decides whether the machinery pays for itself.
categories command
Command categories renders the categorical chart from the README.
 Command categories renders the categorical chart from the README.
contour command
Command contour draws one field three ways, off one colour scale.
 Command contour draws one field three ways, off one colour scale.
dashboard command
Command dashboard renders the v0.3 additions: small multiples, annotations, a colourbar, a grid of subplots, and PDF output.
 Command dashboard renders the v0.3 additions: small multiples, annotations, a colourbar, a grid of subplots, and PDF output.
diagnostics command
Command diagnostics writes a normal QQ plot and a chart with placed labels.
 Command diagnostics writes a normal QQ plot and a chart with placed labels.
distributions command
Command distributions renders the v0.9 charts from the README.
 Command distributions renders the v0.9 charts from the README.
groups command
Command groups renders the grouped charts from the README.
 Command groups renders the grouped charts from the README.
linked command
Command linked wires two charts together through the host program.
 Command linked wires two charts together through the host program.
machine command
Command machine renders the chart tracks exist for: a shopfloor terminal's view of one machine's last hour.
 Command machine renders the chart tracks exist for: a shopfloor terminal's view of one machine's last hour.
nichols command
Command nichols renders the chart a family of curves unlocks.
 Command nichols renders the chart a family of curves unlocks.
polar command
Command polar renders the charts a coordinate system unlocks.
 Command polar renders the charts a coordinate system unlocks.
relational command
Command relational renders the charts a layout in the unit square unlocks.
 Command relational renders the charts a layout in the unit square unlocks.
signal command
Command signal renders the chart from CONCEPT.md §13.
 Command signal renders the chart from CONCEPT.md §13.
smith command
Command smith renders the charts a third coordinate system unlocks.
 Command smith renders the charts a third coordinate system unlocks.
status command
Command status renders the two charts a path coloured from a column is for: a measurement read against a limit, and a series read against the state of the thing that produced it.
 Command status renders the two charts a path coloured from a column is for: a measurement read against a limit, and a series read against the state of the thing that produced it.
stream command
Command stream draws a live chart over a growing series.
 Command stream draws a live chart over a growing series.
surface command
Command surface renders the chart a third scale unlocks.
 Command surface renders the chart a third scale unlocks.
transition command
Command transition animates a chart between two states of the same table.
 Command transition animates a chart between two states of the same table.
views command
Command views renders one scene from several cameras at once.
 Command views renders one scene from several cameras at once.
web command
Command web draws an interactive chart in a browser.
 Command web draws an interactive chart in a browser.
Package facet splits one chart into small multiples.
 Package facet splits one chart into small multiples.
Package geom holds the visual marks a chart is made of.
 Package geom holds the visual marks a chart is made of.
Package interact turns a rendered chart into something a pointer can ask questions of.
 Package interact turns a rendered chart into something a pointer can ask questions of.
internal
cmd/release command
Command release tags a release of every module in this repository.
 Command release tags a release of every module in this repository.
cmd/releasecheck command
Command releasecheck verifies a module against its published dependencies, with the development workspace disabled.
 Command releasecheck verifies a module against its published dependencies, with the development workspace disabled.
fontmetrics
Package fontmetrics answers "how wide is this string" using nothing but the standard library.
 Package fontmetrics answers "how wide is this string" using nothing but the standard library.
irtest
Package irtest provides a recording ir.Backend for tests.
 Package irtest provides a recording ir.Backend for tests.
layout
Package layout decides where the plot area, titles and guides go.
 Package layout decides where the plot area, titles and guides go.
release
Package release holds what the release commands share: the list of modules this repository publishes, the tag each one is released under, and the check that a module builds against the versions its own go.mod names.
 Package release holds what the release commands share: the list of modules this repository publishes, the tag each one is released under, and the check that a module builds against the versions its own go.mod names.
sfnt
Package sfnt reads the parts of a TrueType or OpenType font that embedding one in a PDF needs, and cuts a subset of it down to the glyphs a document actually uses.
 Package sfnt reads the parts of a TrueType or OpenType font that embedding one in a PDF needs, and cuts a subset of it down to the glyphs a document actually uses.
sfnttest
Package sfnttest builds a font file byte by byte.
 Package sfnttest builds a font file byte by byte.
svgdiff
Package svgdiff compares two SVG documents as drawings rather than as bytes.
 Package svgdiff compares two SVG documents as drawings rather than as bytes.
Package ir defines figure's intermediate representation: a small, backend-agnostic scene description, plus the Backend interface every renderer implements.
 Package ir defines figure's intermediate representation: a small, backend-agnostic scene description, plus the Backend interface every renderer implements.
Package mathtext typesets mathematical notation for chart labels.
 Package mathtext typesets mathematical notation for chart labels.
Package palette provides colours and colour sequences for charts.
 Package palette provides colours and colour sequences for charts.
Package render lowers a resolved chart into IR.
 Package render lowers a resolved chart into IR.
Package scale maps data values onto visual positions and generates the ticks that label them.
 Package scale maps data values onto visual positions and generates the ticks that label them.
Package spec writes a chart down as JSON and reads it back.
 Package spec writes a chart down as JSON and reads it back.
Package stat aggregates data before it is drawn.
 Package stat aggregates data before it is drawn.
Package theme holds the visual tokens a chart is drawn with: colours, fonts, sizes and spacings.
 Package theme holds the visual tokens a chart is drawn with: colours, fonts, sizes and spacings.
Package three draws a chart whose x, y and z are all data.
 Package three draws a chart whose x, y and z are all data.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.