README

hplot

GoDoc

hplot is a WIP package relying on gonum/plot to plot histograms, n-tuples and functions.

Installation

$ go get go-hep.org/x/hep/hplot

Documentation

Is available on godoc:

https://godoc.org/go-hep.org/x/hep/hplot

Examples

1D histogram

hist-example

func ExampleH1D() {
	const npoints = 10000

	// Create a normal distribution.
	dist := distuv.Normal{
		Mu:    0,
		Sigma: 1,
		Src:   rand.New(rand.NewSource(0)),
	}

	// Draw some random values from the standard
	// normal distribution.
	hist := hbook.NewH1D(20, -4, +4)
	for i := 0; i < npoints; i++ {
		v := dist.Rand()
		hist.Fill(v, 1)
	}

	// normalize histogram
	area := 0.0
	for _, bin := range hist.Binning.Bins {
		area += bin.SumW() * bin.XWidth()
	}
	hist.Scale(1 / area)

	// Make a plot and set its title.
	p := hplot.New()
	p.Title.Text = "Histogram"
	p.X.Label.Text = "X"
	p.Y.Label.Text = "Y"

	// Create a histogram of our values drawn
	// from the standard normal.
	h := hplot.NewH1D(hist)
	h.Infos.Style = hplot.HInfoSummary
	p.Add(h)

	// The normal distribution function
	norm := hplot.NewFunction(dist.Prob)
	norm.Color = color.RGBA{R: 255, A: 255}
	norm.Width = vg.Points(2)
	p.Add(norm)

	// draw a grid
	p.Add(hplot.NewGrid())

	// Save the plot to a PNG file.
	if err := p.Save(6*vg.Inch, -1, "testdata/h1d_plot.png"); err != nil {
		log.Fatalf("error saving plot: %v\n", err)
	}
}
1D histogram with y-error bars

hist-yerrs-example

func ExampleH1D_withYErrBars() {
	const npoints = 100

	// Create a normal distribution.
	dist := distuv.Normal{
		Mu:    0,
		Sigma: 1,
		Src:   rand.New(rand.NewSource(0)),
	}

	// Draw some random values from the standard
	// normal distribution.
	hist := hbook.NewH1D(20, -4, +4)
	for i := 0; i < npoints; i++ {
		v := dist.Rand()
		hist.Fill(v, 1)
	}

	// normalize histogram
	area := 0.0
	for _, bin := range hist.Binning.Bins {
		area += bin.SumW() * bin.XWidth()
	}
	hist.Scale(1 / area)

	// Make a plot and set its title.
	p := hplot.New()
	p.Title.Text = "Histogram"
	p.X.Label.Text = "X"
	p.Y.Label.Text = "Y"

	// Create a histogram of our values drawn
	// from the standard normal.
	h := hplot.NewH1D(hist,
		hplot.WithHInfo(hplot.HInfoSummary),
		hplot.WithYErrBars(true),
	)
	h.YErrs.LineStyle.Color = color.RGBA{R: 255, A: 255}
	p.Add(h)

	// The normal distribution function
	norm := hplot.NewFunction(dist.Prob)
	norm.Color = color.RGBA{R: 255, A: 255}
	norm.Width = vg.Points(2)
	p.Add(norm)

	// draw a grid
	p.Add(hplot.NewGrid())

	// Save the plot to a PNG file.
	if err := p.Save(6*vg.Inch, -1, "testdata/h1d_yerrs.png"); err != nil {
		log.Fatalf("error saving plot: %v\n", err)
	}
}
1D histogram with y-error bars, no lines

hist-glyphs-example

func ExampleH1D_withYErrBarsAndData() {
	const npoints = 100

	// Create a normal distribution.
	dist := distuv.Normal{
		Mu:    0,
		Sigma: 1,
		Src:   rand.New(rand.NewSource(0)),
	}

	// Draw some random values from the standard
	// normal distribution.
	hist := hbook.NewH1D(20, -4, +4)
	for i := 0; i < npoints; i++ {
		v := dist.Rand()
		hist.Fill(v, 1)
	}

	// normalize histogram
	area := 0.0
	for _, bin := range hist.Binning.Bins {
		area += bin.SumW() * bin.XWidth()
	}
	hist.Scale(1 / area)

	// Make a plot and set its title.
	p := hplot.New()
	p.Title.Text = "Histogram"
	p.X.Label.Text = "X"
	p.Y.Label.Text = "Y"

	p.Legend.Top = true
	p.Legend.Left = true

	// Create a histogram of our values drawn
	// from the standard normal.
	h := hplot.NewH1D(hist,
		hplot.WithHInfo(hplot.HInfoSummary),
		hplot.WithYErrBars(true),
		hplot.WithGlyphStyle(draw.GlyphStyle{
			Shape:  draw.CrossGlyph{},
			Color:  color.Black,
			Radius: vg.Points(2),
		}),
	)
	h.GlyphStyle.Shape = draw.CircleGlyph{}
	h.YErrs.LineStyle.Color = color.Black
	h.LineStyle.Width = 0 // disable histogram lines
	p.Add(h)
	p.Legend.Add("data", h)

	// The normal distribution function
	norm := hplot.NewFunction(dist.Prob)
	norm.Color = color.RGBA{R: 255, A: 255}
	norm.Width = vg.Points(2)
	p.Add(norm)
	p.Legend.Add("model", norm)

	// draw a grid
	p.Add(hplot.NewGrid())

	// Save the plot to a PNG file.
	if err := p.Save(6*vg.Inch, -1, "testdata/h1d_glyphs.png"); err != nil {
		log.Fatalf("error saving plot: %v\n", err)
	}
}
1D histogram with y-error bars and error bands

hist-yerrs-band-example

func ExampleH1D_withYErrBars_withBand() {
	const npoints = 100

	// Create a normal distribution.
	dist := distuv.Normal{
		Mu:    0,
		Sigma: 1,
		Src:   rand.New(rand.NewSource(0)),
	}

	// Draw some random values from the standard
	// normal distribution.
	hist := hbook.NewH1D(20, -4, +4)
	for i := 0; i < npoints; i++ {
		v := dist.Rand()
		hist.Fill(v, 1)
	}

	// normalize histogram
	area := 0.0
	for _, bin := range hist.Binning.Bins {
		area += bin.SumW() * bin.XWidth()
	}
	hist.Scale(1 / area)

	// Make a plot and set its title.
	p := hplot.New()
	p.Title.Text = "Histogram"
	p.X.Label.Text = "X"
	p.Y.Label.Text = "Y"

	// Create a histogram of our values drawn
	// from the standard normal.
	h := hplot.NewH1D(hist,
		hplot.WithHInfo(hplot.HInfoSummary),
		hplot.WithYErrBars(true),
		hplot.WithBand(true),
	)
	h.YErrs.LineStyle.Color = color.RGBA{R: 255, A: 255}
	p.Add(h)

	// The normal distribution function
	norm := hplot.NewFunction(dist.Prob)
	norm.Color = color.RGBA{R: 255, A: 255}
	norm.Width = vg.Points(2)
	p.Add(norm)

	// draw a grid
	p.Add(hplot.NewGrid())

	// Save the plot to a PNG file.
	if err := p.Save(6*vg.Inch, -1, "testdata/h1d_yerrs_band.png"); err != nil {
		log.Fatalf("error saving plot: %v\n", err)
	}
}
Tiles of 1D histograms

tiled-plot

func ExampleTiledPlot() {
	tp := hplot.NewTiledPlot(draw.Tiles{Cols: 3, Rows: 2})

	// Create a normal distribution.
	dist := distuv.Normal{
		Mu:    0,
		Sigma: 1,
		Src:   rand.New(rand.NewSource(0)),
	}

	newHist := func(p *hplot.Plot) {
		const npoints = 10000
		hist := hbook.NewH1D(20, -4, +4)
		for i := 0; i < npoints; i++ {
			v := dist.Rand()
			hist.Fill(v, 1)
		}

		h := hplot.NewH1D(hist)
		p.Add(h)
	}

	for i := 0; i < tp.Tiles.Rows; i++ {
		for j := 0; j < tp.Tiles.Cols; j++ {
			p := tp.Plot(i, j)
			p.X.Min = -5
			p.X.Max = +5
			newHist(p)
			p.Title.Text = fmt.Sprintf("hist - (%02d, %02d)", i, j)
		}
	}

	// remove plot at (0,1)
	tp.Plots[1] = nil

	err := tp.Save(15*vg.Centimeter, -1, "testdata/tiled_plot_histogram.png")
	if err != nil {
		log.Fatalf("error: %+v\n", err)
	}
}

tiled-plot-aligned

func ExampleTiledPlot_align() {
	tp := hplot.NewTiledPlot(draw.Tiles{
		Cols: 3, Rows: 3,
		PadX: 20, PadY: 20,
	})
	tp.Align = true

	points := func(i, j int) []hbook.Point2D {
		n := i*tp.Tiles.Cols + j + 1
		i += 1
		j = int(math.Pow(10, float64(n)))

		var pts []hbook.Point2D
		for ii := 0; ii < 10; ii++ {
			pts = append(pts, hbook.Point2D{
				X: float64(i + ii),
				Y: float64(j + ii + 1),
			})
		}
		return pts

	}

	for i := 0; i < tp.Tiles.Rows; i++ {
		for j := 0; j < tp.Tiles.Cols; j++ {
			p := tp.Plot(i, j)
			p.X.Min = -5
			p.X.Max = +5
			s := hplot.NewS2D(hbook.NewS2D(points(i, j)...))
			s.GlyphStyle.Color = color.RGBA{R: 255, A: 255}
			s.GlyphStyle.Radius = vg.Points(4)
			p.Add(s)

			p.Title.Text = fmt.Sprintf("hist - (%02d, %02d)", i, j)
		}
	}

	// remove plot at (1,1)
	tp.Plots[4] = nil

	err := tp.Save(15*vg.Centimeter, -1, "testdata/tiled_plot_aligned_histogram.png")
	if err != nil {
		log.Fatalf("error: %+v\n", err)
	}
}
Subplots

sub-plot

https://godoc.org/go-hep.org/x/hep/hplot#example-package--Subplot

Ratio-plots

ratio-plot

func ExampleRatioPlot() {

	const npoints = 10000

	// Create a normal distribution.
	dist := distuv.Normal{
		Mu:    0,
		Sigma: 1,
		Src:   rand.New(rand.NewSource(0)),
	}

	hist1 := hbook.NewH1D(20, -4, +4)
	hist2 := hbook.NewH1D(20, -4, +4)

	for i := 0; i < npoints; i++ {
		v1 := dist.Rand() - 0.5
		v2 := dist.Rand() + 0.5
		hist1.Fill(v1, 1)
		hist2.Fill(v2, 1)
	}

	rp := hplot.NewRatioPlot()
	rp.Ratio = 0.3

	// Make a plot and set its title.
	rp.Top.Title.Text = "Histos"
	rp.Top.Y.Label.Text = "Y"

	// Create a histogram of our values drawn
	// from the standard normal.
	h1 := hplot.NewH1D(hist1)
	h1.FillColor = color.NRGBA{R: 255, A: 100}
	rp.Top.Add(h1)

	h2 := hplot.NewH1D(hist2)
	h2.FillColor = color.NRGBA{B: 255, A: 100}
	rp.Top.Add(h2)

	rp.Top.Add(hplot.NewGrid())

	hist3 := hbook.NewH1D(20, -4, +4)
	for i := 0; i < hist3.Len(); i++ {
		v1 := hist1.Value(i)
		v2 := hist2.Value(i)
		x1, _ := hist1.XY(i)
		hist3.Fill(x1, v1-v2)
	}

	hdiff := hplot.NewH1D(hist3)

	rp.Bottom.X.Label.Text = "X"
	rp.Bottom.Y.Label.Text = "Delta-Y"
	rp.Bottom.Add(hdiff)
	rp.Bottom.Add(hplot.NewGrid())

	const (
		width  = 15 * vg.Centimeter
		height = width / math.Phi
	)

	err := hplot.Save(rp, width, height, "testdata/diff_plot.png")
	if err != nil {
		log.Fatalf("error: %v\n", err)
	}
}
LaTeX-plots

latex-plot (PDF)

https://godoc.org/go-hep.org/x/hep/hplot#example-package--Latexplot

2D histogram
func ExampleH2D() {
	h := hbook.NewH2D(100, -10, 10, 100, -10, 10)

	const npoints = 10000

	dist, ok := distmv.NewNormal(
		[]float64{0, 1},
		mat.NewSymDense(2, []float64{4, 0, 0, 2}),
		rand.New(rand.NewSource(1234)),
	)
	if !ok {
		log.Fatalf("error creating distmv.Normal")
	}

	v := make([]float64, 2)
	// Draw some random values from the standard
	// normal distribution.
	for i := 0; i < npoints; i++ {
		v = dist.Rand(v)
		h.Fill(v[0], v[1], 1)
	}

	p := hplot.New()
	p.Title.Text = "Hist-2D"
	p.X.Label.Text = "x"
	p.Y.Label.Text = "y"

	p.Add(hplot.NewH2D(h, nil))
	p.Add(plotter.NewGrid())
	err := p.Save(10*vg.Centimeter, 10*vg.Centimeter, "testdata/h2d_plot.png")
	if err != nil {
		log.Fatal(err)
	}
}

h2d-example

Scatter2D
func ExampleS2D() {
	const npoints = 1000

	dist, ok := distmv.NewNormal(
		[]float64{0, 1},
		mat.NewSymDense(2, []float64{4, 0, 0, 2}),
		rand.New(rand.NewSource(1234)),
	)
	if !ok {
		log.Fatalf("error creating distmv.Normal")
	}

	s2d := hbook.NewS2D()

	v := make([]float64, 2)
	// Draw some random values from the standard
	// normal distribution.
	for i := 0; i < npoints; i++ {
		v = dist.Rand(v)
		s2d.Fill(hbook.Point2D{X: v[0], Y: v[1]})
	}

	p := hplot.New()
	p.Title.Text = "Scatter-2D"
	p.X.Label.Text = "X"
	p.Y.Label.Text = "Y"
	p.Add(plotter.NewGrid())

	s := hplot.NewS2D(s2d)
	s.GlyphStyle.Color = color.RGBA{R: 255, A: 255}
	s.GlyphStyle.Radius = vg.Points(2)

	p.Add(s)

	err := p.Save(10*vg.Centimeter, 10*vg.Centimeter, "testdata/s2d.png")
	if err != nil {
		log.Fatal(err)
	}
}

s2d-example s2d-errbars-example s2d-band-example s2d-steps-example s2d-steps-band-example

Vertical lines
func ExampleVLine() {
	p := hplot.New()
	p.Title.Text = "vlines"
	p.X.Min = 0
	p.X.Max = 10
	p.Y.Min = 0
	p.Y.Max = 10

	var (
		left  = color.RGBA{B: 255, A: 255}
		right = color.RGBA{R: 255, A: 255}
	)

	p.Add(
		hplot.VLine(2.5, left, nil),
		hplot.VLine(5, nil, nil),
		hplot.VLine(7.5, nil, right),
	)

	err := p.Save(10*vg.Centimeter, -1, "testdata/vline.png")
	if err != nil {
		log.Fatalf("error: %+v", err)
	}
}

vline-example

Horizontal lines
func ExampleHLine() {
	p := hplot.New()
	p.Title.Text = "hlines"
	p.X.Min = 0
	p.X.Max = 10
	p.Y.Min = 0
	p.Y.Max = 10

	var (
		top    = color.RGBA{B: 255, A: 255}
		bottom = color.RGBA{R: 255, A: 255}
	)

	p.Add(
		hplot.HLine(2.5, nil, bottom),
		hplot.HLine(5, nil, nil),
		hplot.HLine(7.5, top, nil),
	)

	err := p.Save(10*vg.Centimeter, -1, "testdata/hline.png")
	if err != nil {
		log.Fatalf("error: %+v", err)
	}
}

hline-example

Band between lines
func ExampleBand() {
	const (
		npoints = 100
		xmax    = 10
	)

	// Create a normal distribution.
	dist := distuv.Normal{
		Mu:    0,
		Sigma: 1,
		Src:   rand.New(rand.NewSource(0)),
	}

	topData := make(plotter.XYs, npoints)
	botData := make(plotter.XYs, npoints)

	// Draw some random values from the standard
	// normal distribution.
	for i := 0; i < npoints; i++ {
		x := float64(i+1) / xmax

		v1 := dist.Rand()
		v2 := dist.Rand()

		topData[i].X = x
		topData[i].Y = 1/x + v1 + 10

		botData[i].X = x
		botData[i].Y = math.Log(x) + v2
	}

	top, err := hplot.NewLine(topData)
	if err != nil {
		log.Fatalf("error: %+v", err)
	}
	top.LineStyle.Color = color.RGBA{R: 255, A: 255}

	bot, err := hplot.NewLine(botData)
	if err != nil {
		log.Fatalf("error: %+v", err)
	}
	bot.LineStyle.Color = color.RGBA{B: 255, A: 255}

	tp := hplot.NewTiledPlot(draw.Tiles{Cols: 1, Rows: 2})

	tp.Plots[0].Title.Text = "Band"
	tp.Plots[0].Add(
		top,
		bot,
		hplot.NewBand(color.Gray{200}, topData, botData),
	)

	tp.Plots[1].Title.Text = "Band"
	var (
		blue = color.RGBA{B: 255, A: 255}
		grey = color.Gray{200}
		band = hplot.NewBand(grey, topData, botData)
	)
	band.LineStyle = plotter.DefaultLineStyle
	band.LineStyle.Color = blue
	tp.Plots[1].Add(band)

	err = tp.Save(10*vg.Centimeter, -1, "testdata/band.png")
	if err != nil {
		log.Fatalf("error: %+v", err)
	}
}

band-example

Plot with borders

One can specify extra-space between the image borders (the physical file canvas) and the actual plot data.

plot-border-example

func ExampleH1D_withPlotBorders() {
	const npoints = 10000

	// Create a normal distribution.
	dist := distuv.Normal{
		Mu:    0,
		Sigma: 1,
		Src:   rand.New(rand.NewSource(0)),
	}

	// Draw some random values from the standard
	// normal distribution.
	hist := hbook.NewH1D(20, -4, +4)
	for i := 0; i < npoints; i++ {
		v := dist.Rand()
		hist.Fill(v, 1)
	}

	// normalize histogram
	area := 0.0
	for _, bin := range hist.Binning.Bins {
		area += bin.SumW() * bin.XWidth()
	}
	hist.Scale(1 / area)

	// Make a plot and set its title.
	p := hplot.New()
	p.Title.Text = "Histogram"
	p.X.Label.Text = "X"
	p.Y.Label.Text = "Y"

	// Create a histogram of our values drawn
	// from the standard normal.
	h := hplot.NewH1D(hist)
	h.Infos.Style = hplot.HInfoSummary
	p.Add(h)

	// The normal distribution function
	norm := hplot.NewFunction(dist.Prob)
	norm.Color = color.RGBA{R: 255, A: 255}
	norm.Width = vg.Points(2)
	p.Add(norm)

	// draw a grid
	p.Add(hplot.NewGrid())

	fig := hplot.Figure(p,
		hplot.WithDPI(96),
		hplot.WithBorder(hplot.Border{
			Right:  25,
			Left:   20,
			Top:    25,
			Bottom: 20,
		}),
	)

	// Save the plot to a PNG file.
	if err := hplot.Save(fig, 6*vg.Inch, -1, "testdata/h1d_borders.png"); err != nil {
		log.Fatalf("error saving plot: %v\n", err)
	}
}
Stack of 1D histograms

hstack-example

func ExampleHStack() {
	h1 := hbook.NewH1D(100, -10, 10)
	h2 := hbook.NewH1D(100, -10, 10)
	h3 := hbook.NewH1D(100, -10, 10)

	const seed = 1234
	fillH1(h1, 10000, -2, 1, seed)
	fillH1(h2, 10000, +3, 3, seed)
	fillH1(h3, 10000, +4, 1, seed)

	colors := []color.Color{
		color.NRGBA{122, 195, 106, 150},
		color.NRGBA{90, 155, 212, 150},
		color.NRGBA{250, 167, 91, 150},
	}

	hh1 := hplot.NewH1D(h1)
	hh1.FillColor = colors[0]
	hh1.LineStyle.Color = color.Black

	hh2 := hplot.NewH1D(h2)
	hh2.FillColor = colors[1]
	hh2.LineStyle.Width = 0

	hh3 := hplot.NewH1D(h3)
	hh3.FillColor = colors[2]
	hh3.LineStyle.Color = color.Black

	hs := []*hplot.H1D{hh1, hh2, hh3}

	tp := hplot.NewTiledPlot(draw.Tiles{Cols: 1, Rows: 3})
	tp.Align = true

	{
		p := tp.Plots[0]
		p.Title.Text = "Histograms"
		p.Y.Label.Text = "Y"
		p.Add(hh1, hh2, hh3, hplot.NewGrid())
		p.Legend.Add("h1", hh1)
		p.Legend.Add("h2", hh2)
		p.Legend.Add("h3", hh3)
		p.Legend.Top = true
		p.Legend.Left = true
	}

	{
		p := tp.Plot(1, 0)
		p.Title.Text = "HStack - stack: OFF"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hs)
		hstack.Stack = hplot.HStackOff
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	{
		p := tp.Plot(2, 0)
		p.Title.Text = "Hstack - stack: ON"
		p.X.Label.Text = "X"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hs, hplot.WithLogY(false))
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	err := tp.Save(15*vg.Centimeter, 15*vg.Centimeter, "testdata/hstack.png")
	if err != nil {
		log.Fatalf("error: %+v", err)
	}

}
Stack of 1D histograms with a band

hstack-band-example

func ExampleHStack_withBand() {
	h1 := hbook.NewH1D(50, -8, 12)
	h2 := hbook.NewH1D(50, -8, 12)
	h3 := hbook.NewH1D(50, -8, 12)

	const seed = 1234
	fillH1(h1, 2000, -2, 1, seed)
	fillH1(h2, 2000, +3, 3, seed)
	fillH1(h3, 2000, +4, 1, seed)

	colors := []color.Color{
		color.NRGBA{122, 195, 106, 150},
		color.NRGBA{90, 155, 212, 150},
		color.NRGBA{250, 167, 91, 150},
	}

	hh1 := hplot.NewH1D(h1, hplot.WithBand(true))
	hh1.FillColor = colors[0]
	hh1.LineStyle.Color = color.Black
	hh1.Band.FillColor = color.NRGBA{G: 210, A: 200}

	hh2 := hplot.NewH1D(h2, hplot.WithBand(false))
	hh2.FillColor = colors[1]
	hh2.LineStyle.Width = 0

	hh3 := hplot.NewH1D(h3, hplot.WithBand(true))
	hh3.FillColor = colors[2]
	hh3.LineStyle.Color = color.Black
	hh3.Band.FillColor = color.NRGBA{R: 220, A: 200}

	hs := []*hplot.H1D{hh1, hh2, hh3}

	hh4 := hplot.NewH1D(h1)
	hh4.FillColor = colors[0]
	hh4.LineStyle.Color = color.Black

	hh5 := hplot.NewH1D(h2)
	hh5.FillColor = colors[1]
	hh5.LineStyle.Width = 0

	hh6 := hplot.NewH1D(h3)
	hh6.FillColor = colors[2]
	hh6.LineStyle.Color = color.Black

	hsHistoNoBand := []*hplot.H1D{hh4, hh5, hh6}

	tp := hplot.NewTiledPlot(draw.Tiles{Cols: 2, Rows: 2})
	tp.Align = true

	{
		p := tp.Plot(0, 0)
		p.Title.Text = "Histos With or Without Band, Stack: OFF"
		p.Title.Padding = 10
		p.X.Label.Text = "X"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hs, hplot.WithBand(true))
		hstack.Stack = hplot.HStackOff
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	{
		p := tp.Plot(0, 1)
		p.Title.Text = "Histos Without Band, Stack: OFF"
		p.Title.Padding = 10
		p.X.Label.Text = "X"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hsHistoNoBand, hplot.WithBand(true))
		hstack.Stack = hplot.HStackOff
		hstack.Band.FillColor = color.NRGBA{R: 100, G: 100, B: 100, A: 200}
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	{
		p := tp.Plot(1, 0)
		p.Title.Text = "Histos With or Without Band, Stack: ON"
		p.Title.Padding = 10
		p.X.Label.Text = "X"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hs, hplot.WithBand(true))
		hstack.Band.FillColor = color.NRGBA{R: 100, G: 100, B: 100, A: 200}
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	{
		p := tp.Plot(1, 1)
		p.Title.Text = "Histos Without Band, Stack: ON"
		p.Title.Padding = 10
		p.X.Label.Text = "X"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hsHistoNoBand, hplot.WithBand(true))
		hstack.Band.FillColor = color.NRGBA{R: 100, G: 100, B: 100, A: 200}
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	err := tp.Save(25*vg.Centimeter, 15*vg.Centimeter, "testdata/hstack_band.png")
	if err != nil {
		log.Fatalf("error: %+v", err)
	}
}
Stack of 1D histograms with a band, with a log-y scale

hstack-logy-example

func ExampleHStack_withLogY() {
	h1 := hbook.NewH1D(50, -8, 12)
	h2 := hbook.NewH1D(50, -8, 12)
	h3 := hbook.NewH1D(50, -8, 12)

	const seed = 1234
	fillH1(h1, 2000, -2, 1, seed)
	fillH1(h2, 2000, +3, 3, seed)
	fillH1(h3, 2000, +4, 1, seed)

	colors := []color.Color{
		color.NRGBA{122, 195, 106, 150},
		color.NRGBA{90, 155, 212, 150},
		color.NRGBA{250, 167, 91, 150},
	}
	logy := hplot.WithLogY(true)

	hh1 := hplot.NewH1D(h1, hplot.WithBand(true), logy)
	hh1.FillColor = colors[0]
	hh1.LineStyle.Color = color.Black
	hh1.Band.FillColor = color.NRGBA{G: 210, A: 200}

	hh2 := hplot.NewH1D(h2, hplot.WithBand(false), logy)
	hh2.FillColor = colors[1]
	hh2.LineStyle.Width = 0

	hh3 := hplot.NewH1D(h3, hplot.WithBand(true), logy)
	hh3.FillColor = colors[2]
	hh3.LineStyle.Color = color.Black
	hh3.Band.FillColor = color.NRGBA{R: 220, A: 200}

	hs := []*hplot.H1D{hh1, hh2, hh3}

	hh4 := hplot.NewH1D(h1, logy)
	hh4.FillColor = colors[0]
	hh4.LineStyle.Color = color.Black

	hh5 := hplot.NewH1D(h2, logy)
	hh5.FillColor = colors[1]
	hh5.LineStyle.Width = 0

	hh6 := hplot.NewH1D(h3, logy)
	hh6.FillColor = colors[2]
	hh6.LineStyle.Color = color.Black

	hsHistoNoBand := []*hplot.H1D{hh4, hh5, hh6}

	tp := hplot.NewTiledPlot(draw.Tiles{Cols: 2, Rows: 2})
	tp.Align = true

	{
		p := tp.Plot(0, 0)
		p.Title.Text = "Histos With or Without Band, Stack: OFF"
		p.Title.Padding = 10
		p.Y.Scale = plot.LogScale{}
		p.Y.Tick.Marker = plot.LogTicks{}
		p.X.Label.Text = "X"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hs, hplot.WithBand(true), logy)
		hstack.Stack = hplot.HStackOff
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	{
		p := tp.Plot(0, 1)
		p.Title.Text = "Histos Without Band, Stack: OFF"
		p.Title.Padding = 10
		p.Y.Scale = plot.LogScale{}
		p.Y.Tick.Marker = plot.LogTicks{}
		p.X.Label.Text = "X"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hsHistoNoBand, hplot.WithBand(true), logy)
		hstack.Stack = hplot.HStackOff
		hstack.Band.FillColor = color.NRGBA{R: 100, G: 100, B: 100, A: 200}
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	{
		p := tp.Plot(1, 0)
		p.Title.Text = "Histos With or Without Band, Stack: ON"
		p.Title.Padding = 10
		p.Y.Scale = plot.LogScale{}
		p.Y.Tick.Marker = plot.LogTicks{}
		p.X.Label.Text = "X"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hs, hplot.WithBand(true), logy)
		hstack.Band.FillColor = color.NRGBA{R: 100, G: 100, B: 100, A: 200}
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	{
		p := tp.Plot(1, 1)
		p.Title.Text = "Histos Without Band, Stack: ON"
		p.Title.Padding = 10
		p.Y.Scale = plot.LogScale{}
		p.Y.Tick.Marker = plot.LogTicks{}
		p.X.Label.Text = "X"
		p.Y.Label.Text = "Y"
		hstack := hplot.NewHStack(hsHistoNoBand, hplot.WithBand(true), logy)
		hstack.Band.FillColor = color.NRGBA{R: 100, G: 100, B: 100, A: 200}
		p.Add(hstack, hplot.NewGrid())
		p.Legend.Add("h1", hs[0])
		p.Legend.Add("h2", hs[1])
		p.Legend.Add("h3", hs[2])
		p.Legend.Top = true
		p.Legend.Left = true
	}

	err := tp.Save(25*vg.Centimeter, 15*vg.Centimeter, "testdata/hstack_logy.png")
	if err != nil {
		log.Fatalf("error: %+v", err)
	}
}

Labels

label-example

func ExampleLabel() {

	// Creating a new plot
	p := hplot.New()
	p.Title.Text = "Plot labels"
	p.X.Min = -10
	p.X.Max = +10
	p.Y.Min = -10
	p.Y.Max = +10

	// Default labels
	l1 := hplot.NewLabel(-8, 5, "(-8,5)\nDefault label")
	p.Add(l1)

	// Label with normalized coordinates.
	l3 := hplot.NewLabel(
		0.5, 0.5,
		"(0.5,0.5)\nLabel with relative coords",
		hplot.WithLabelNormalized(true),
	)
	p.Add(l3)

	// Label with normalized coordinates and auto-adjustement.
	l4 := hplot.NewLabel(
		0.95, 0.95,
		"(0.95,0.95)\nLabel at the canvas edge, with AutoAdjust",
		hplot.WithLabelNormalized(true),
		hplot.WithLabelAutoAdjust(true),
	)
	p.Add(l4)

	// Label with a customed TextStyle
	usrFont, err := vg.MakeFont("Courier-Bold", 12)
	if err != nil {
		panic(fmt.Errorf("could not create font (Courier-Bold, 12): %w", err))
	}
	sty := draw.TextStyle{
		Color: plotutil.Color(2),
		Font:  usrFont,
	}
	l5 := hplot.NewLabel(
		0.0, 0.1,
		"(0.0,0.1)\nLabel with a user-defined font",
		hplot.WithLabelTextStyle(sty),
		hplot.WithLabelNormalized(true),
	)
	p.Add(l5)

	p.Add(plotter.NewGlyphBoxes())
	p.Add(hplot.NewGrid())

	// Save the plot to a PNG file.
	err = p.Save(15*vg.Centimeter, -1, "testdata/label_plot.png")
	if err != nil {
		log.Fatalf("error saving plot: %v\n", err)
	}
}
Expand ▾ Collapse ▴

Documentation

Overview

    Package hplot is a package to plot histograms, n-tuples and functions

    Example (Latexplot)
    Output:
    
    
    Example (Subplot)

      An example of a plot + sub-plot

      Output:
      
      

      Index

      Examples

      Constants

      This section is empty.

      Variables

      This section is empty.

      Functions

      func Dims

      func Dims(width, height vg.Length) (w, h vg.Length)

      func NewGrid

      func NewGrid() *plotter.Grid

        NewGrid returns a new grid with both vertical and horizontal lines using the default grid line style.

        func NewLine

        func NewLine(xys plotter.XYer) (*plotter.Line, error)

          NewLine returns a Line that uses the default line style and does not draw glyphs.

          func NewScatter

          func NewScatter(xys plotter.XYer) (*plotter.Scatter, error)

            NewScatter returns a Scatter that uses the default glyph style.

            func Save

            func Save(p Drawer, w, h vg.Length, fnames ...string) (err error)

              Save saves the plot to an image file. The file format is determined by the extension.

              Supported extensions are:

              .eps, .jpg, .jpeg, .pdf, .png, .svg, .tex, .tif and .tiff.
              

              If w or h are <= 0, the value is chosen such that it follows the Golden Ratio. If w and h are <= 0, the values are chosen such that they follow the Golden Ratio (the width is defaulted to vgimg.DefaultWidth).

              Example
              Output:
              
              

              func Show

              func Show(p Drawer, w, h vg.Length, format string) ([]byte, error)

                Show displays the plot according to format, returning the raw bytes and an error, if any.

                If format is the empty string, then "png" is selected. The list of accepted format strings is the same one than from the gonum.org/v1/plot/vg/draw.NewFormattedCanvas function.

                func WriterTo

                func WriterTo(p Drawer, w, h vg.Length, format string) (io.WriterTo, error)

                WriterTo returns an io.WriterTo that will write the plots as the specified image format.

                Supported formats are the same ones than hplot.Plot.WriterTo

                If w or h are <= 0, the value is chosen such that it follows the Golden Ratio. If w and h are <= 0, the values are chosen such that they follow the Golden Ratio (the width is defaulted to vgimg.DefaultWidth).

                func ZipXY

                func ZipXY(x, y []float64) plotter.XYer

                  ZipXY zips together 2 slices x and y in such a way to implement the plotter.XYer interface.

                  ZipXY panics if the slices are not of the same length.

                  Types

                  type Band

                  type Band struct {
                  
                  	// LineStyle is the style of the line contouring the band.
                  	// Use zero width to disable.
                  	draw.LineStyle
                  
                  	// FillColor is the color to fill the area between
                  	// the top and bottom data points.
                  	// Use nil to disable the filling.
                  	FillColor color.Color
                  	// contains filtered or unexported fields
                  }

                    Band implements the plot.Plotter interface, drawing a colored band made of two lines.

                    Example

                      An example of making a colored band plot

                      Output:
                      
                      

                      func NewBand

                      func NewBand(fill color.Color, top, bottom plotter.XYer) *Band

                      func (*Band) DataRange

                      func (band *Band) DataRange() (xmin, xmax, ymin, ymax float64)

                        DataRange returns the minimum and maximum x and y values, implementing the plot.DataRanger interface.

                        func (*Band) Plot

                        func (band *Band) Plot(c draw.Canvas, plt *plot.Plot)

                        type BinnedErrBand

                        type BinnedErrBand struct {
                        
                        	// Data for every bins.
                        	Counts []hbook.Count
                        
                        	// LineStyle is the style of the line
                        	// contouring the band.
                        	// Use zero width to disable.
                        	draw.LineStyle
                        
                        	// FillColor is the color to fill the area
                        	// between the top and bottom data points.
                        	// Use nil to disable the filling.
                        	FillColor color.Color
                        
                        	// LogY allows rendering with a log-scaled Y axis.
                        	// When enabled, bins with negative or zero minimal value (val-err)
                        	// will be discarded from the error band.
                        	// The lowest Y value for the DataRange will be corrected to leave an
                        	// arbitrary amount of height for the smallest bin entry so it is visible
                        	// on the final plot.
                        	LogY bool
                        }

                          BinnedErrBand implements the plot.Plotter interface, drawing a colored band for the error on any binned quantity.

                          Example

                            An example of making a colored binned error band from scratch.

                            Output:
                            
                            
                            Example (FromH1D)
                            Output:
                            
                            

                            func NewBinnedErrBand

                            func NewBinnedErrBand(cs []hbook.Count) *BinnedErrBand

                              NewBinnedErrBand creates a binned error band from a slice of count.

                              func (*BinnedErrBand) DataRange

                              func (b *BinnedErrBand) DataRange() (xmin, xmax, ymin, ymax float64)

                                DataRange returns the minimum and maximum x and y values, implementing the plot.DataRanger interface.

                                func (*BinnedErrBand) Plot

                                func (b *BinnedErrBand) Plot(c draw.Canvas, plt *plot.Plot)

                                  Plot implements the Plotter interface, drawing a colored box defined by width of bins (x-axis) and error (y-axis).

                                  type Border

                                  type Border struct {
                                  	Left   vg.Length
                                  	Right  vg.Length
                                  	Bottom vg.Length
                                  	Top    vg.Length
                                  }

                                    Border specifies the borders' sizes, the space between the end of the plot image (PDF, PNG, ...) and the actual plot.

                                    type Drawer

                                    type Drawer interface {
                                    	Draw(draw.Canvas)
                                    }

                                      Drawer is the interface that wraps the Draw method.

                                      type Fig

                                      type Fig struct {
                                      	// Plot is a gonum/plot.Plot like value.
                                      	Plot Drawer
                                      
                                      	// Border specifies the borders' sizes, the space between the
                                      	// end of the plot image (PDF, PNG, ...) and the actual plot.
                                      	Border Border
                                      
                                      	// Latex handles the generation of PDFs from .tex files.
                                      	// The default is to use htex.NoopHandler (a no-op).
                                      	// To enable the automatic generation of PDFs, use DefaultHandler:
                                      	//  p := hplot.Wrap(plt)
                                      	//  p.Latex = htex.DefaultHandler
                                      	Latex htex.Handler
                                      
                                      	// DPI is the dot-per-inch for PNG,JPEG,... plots.
                                      	DPI float64
                                      }

                                        Fig is a figure, holding a plot and figure-level customizations.

                                        func Figure

                                        func Figure(p Drawer, opts ...FigOption) *Fig

                                          Figure creates a new figure from a plot and options. Figure returns a value implementing the Drawer interface.

                                          func (*Fig) Draw

                                          func (fig *Fig) Draw(dc draw.Canvas)

                                          type FigOption

                                          type FigOption func(fig *Fig)

                                            FigOption allows to customize the creation of figures.

                                            func WithBorder

                                            func WithBorder(b Border) FigOption

                                              WithBorder allows to specify the borders' sizes, the space between the end of the plot image (PDF, PNG, ...) and the actual plot.

                                              func WithDPI

                                              func WithDPI(dpi float64) FigOption

                                                WithDPI allows to modify the default DPI of a plot.

                                                func WithLatexHandler

                                                func WithLatexHandler(h htex.Handler) FigOption

                                                  WithLatexHandler allows to enable the automatic generation of PDFs from .tex files. To enable the automatic generation of PDFs, use DefaultHandler:

                                                  WithLatexHandler(htex.DefaultHandler)
                                                  

                                                  type FreqTicks

                                                  type FreqTicks struct {
                                                  	N    int // number of ticks
                                                  	Freq int // frequency of labeled ticks
                                                  }

                                                    FreqTicks implements a simple plot.Ticker scheme. FreqTicks will generate N ticks where 1 every Freq tick will be labeled.

                                                    func (FreqTicks) Ticks

                                                    func (ft FreqTicks) Ticks(min, max float64) []plot.Tick

                                                      Ticks returns Ticks in a specified range

                                                      type Function

                                                      type Function struct {
                                                      	F func(x float64) (y float64)
                                                      
                                                      	// XMin and XMax specify the range
                                                      	// of x values to pass to F.
                                                      	XMin, XMax float64
                                                      
                                                      	Samples int
                                                      
                                                      	draw.LineStyle
                                                      
                                                      	// LogY allows rendering with a log-scaled Y axis.
                                                      	// When enabled, function values returning 0 will be discarded from
                                                      	// the final plot.
                                                      	LogY bool
                                                      }

                                                        Function implements the Plotter interface, drawing a line for the given function.

                                                        Example

                                                          ExampleFunction draws some functions.

                                                          Output:
                                                          
                                                          
                                                          Example (LogY)

                                                            ExampleFunction_logY draws a function with a Log-Y axis.

                                                            Output:
                                                            
                                                            

                                                            func NewFunction

                                                            func NewFunction(f func(float64) float64) *Function

                                                              NewFunction returns a Function that plots F using the default line style with 50 samples.

                                                              func (*Function) Plot

                                                              func (f *Function) Plot(c draw.Canvas, p *plot.Plot)

                                                                Plot implements the Plotter interface, drawing a line that connects each point in the Line.

                                                                func (Function) Thumbnail

                                                                func (f Function) Thumbnail(c *draw.Canvas)

                                                                  Thumbnail draws a line in the given style down the center of a DrawArea as a thumbnail representation of the LineStyle of the function.

                                                                  type H1D

                                                                  type H1D struct {
                                                                  	// Hist is the histogramming data
                                                                  	Hist *hbook.H1D
                                                                  
                                                                  	// FillColor is the color used to fill each
                                                                  	// bar of the histogram.  If the color is nil
                                                                  	// then the bars are not filled.
                                                                  	FillColor color.Color
                                                                  
                                                                  	// LineStyle is the style of the outline of each
                                                                  	// bar of the histogram.
                                                                  	draw.LineStyle
                                                                  
                                                                  	// GlyphStyle is the style of the glyphs drawn
                                                                  	// at the top of each histogram bar.
                                                                  	GlyphStyle draw.GlyphStyle
                                                                  
                                                                  	// LogY allows rendering with a log-scaled Y axis.
                                                                  	// When enabled, histogram bins with no entries will be discarded from
                                                                  	// the histogram's DataRange.
                                                                  	// The lowest Y value for the DataRange will be corrected to leave an
                                                                  	// arbitrary amount of height for the smallest bin entry so it is visible
                                                                  	// on the final plot.
                                                                  	LogY bool
                                                                  
                                                                  	// InfoStyle is the style of infos displayed for
                                                                  	// the histogram (entries, mean, rms).
                                                                  	Infos HInfos
                                                                  
                                                                  	// YErrs is the y error bars plotter.
                                                                  	YErrs *plotter.YErrorBars
                                                                  
                                                                  	// Band displays a colored band between the y-min and y-max error bars.
                                                                  	// The band is shown in the legend thumbnail only if there is no filling.
                                                                  	Band *BinnedErrBand
                                                                  }

                                                                    H1D implements the plotter.Plotter interface, drawing a histogram of the data.

                                                                    Example

                                                                      An example of making a 1D-histogram.

                                                                      Output:
                                                                      
                                                                      
                                                                      Example (LegendStyle)

                                                                        An example showing legend with different style

                                                                        Output:
                                                                        
                                                                        
                                                                        Example (LogScaleY)
                                                                        Output:
                                                                        
                                                                        
                                                                        Example (ToPDF)

                                                                          An example of making a 1D-histogram and saving to a PDF

                                                                          Output:
                                                                          
                                                                          
                                                                          Example (WithPlotBorders)

                                                                            An example of making a 1D-histogram.

                                                                            Output:
                                                                            
                                                                            
                                                                            Example (WithYErrBars)

                                                                              An example of making a 1D-histogram with y-error bars.

                                                                              Output:
                                                                              
                                                                              
                                                                              Example (WithYErrBarsAndData)

                                                                                An example of making a 1D-histogram with y-error bars and no histogram rectangle.

                                                                                Output:
                                                                                
                                                                                
                                                                                Example (WithYErrBars_withBand)

                                                                                  An example of making a 1D-histogram with y-error bars and the associated band.

                                                                                  Output:
                                                                                  
                                                                                  

                                                                                  func NewH1D

                                                                                  func NewH1D(h *hbook.H1D, opts ...Options) *H1D

                                                                                    NewH1D returns a new histogram, as in NewH1DFromXYer, except that it accepts a hbook.H1D instead of a plotter.XYer

                                                                                    func NewH1FromValuer

                                                                                    func NewH1FromValuer(vs plotter.Valuer, n int, opts ...Options) *H1D

                                                                                      NewH1FromValuer returns a new histogram, as in NewH1FromXYer, except that it accepts a plotter.Valuer instead of an XYer.

                                                                                      func NewH1FromXYer

                                                                                      func NewH1FromXYer(xy plotter.XYer, n int, opts ...Options) *H1D

                                                                                        NewH1FromXYer returns a new histogram that represents the distribution of values using the given number of bins.

                                                                                        Each y value is assumed to be the frequency count for the corresponding x.

                                                                                        It panics if the number of bins is non-positive.

                                                                                        func (*H1D) DataRange

                                                                                        func (h *H1D) DataRange() (xmin, xmax, ymin, ymax float64)

                                                                                          DataRange returns the minimum and maximum X and Y values

                                                                                          func (*H1D) GlyphBoxes

                                                                                          func (h *H1D) GlyphBoxes(p *plot.Plot) []plot.GlyphBox

                                                                                            GlyphBoxes returns a slice of GlyphBoxes, one for each of the bins, implementing the plot.GlyphBoxer interface.

                                                                                            func (*H1D) Plot

                                                                                            func (h *H1D) Plot(c draw.Canvas, p *plot.Plot)

                                                                                              Plot implements the Plotter interface, drawing a line that connects each point in the Line.

                                                                                              func (*H1D) Thumbnail

                                                                                              func (h *H1D) Thumbnail(c *draw.Canvas)

                                                                                                Thumbnail draws a rectangle in the given style of the histogram.

                                                                                                type H2D

                                                                                                type H2D struct {
                                                                                                	// H is the histogramming data
                                                                                                	H *hbook.H2D
                                                                                                
                                                                                                	// InfoStyle is the style of infos displayed for
                                                                                                	// the histogram (entries, mean, rms)
                                                                                                	Infos HInfos
                                                                                                
                                                                                                	// HeatMap implements the Plotter interface, drawing
                                                                                                	// a heat map of the values in the 2-d histogram.
                                                                                                	HeatMap *plotter.HeatMap
                                                                                                }

                                                                                                  H2D implements the plotter.Plotter interface, drawing a 2-dim histogram of the data.

                                                                                                  Example
                                                                                                  Output:
                                                                                                  
                                                                                                  

                                                                                                  func NewH2D

                                                                                                  func NewH2D(h *hbook.H2D, p palette.Palette) *H2D

                                                                                                    NewH2D returns a new 2-dim histogram from a hbook.H2D.

                                                                                                    func (*H2D) DataRange

                                                                                                    func (h *H2D) DataRange() (xmin, xmax, ymin, ymax float64)

                                                                                                      DataRange implements the DataRange method of the plot.DataRanger interface.

                                                                                                      func (*H2D) GlyphBoxes

                                                                                                      func (h *H2D) GlyphBoxes(p *plot.Plot) []plot.GlyphBox

                                                                                                        GlyphBoxes returns a slice of GlyphBoxes, one for each of the bins, implementing the plot.GlyphBoxer interface.

                                                                                                        func (*H2D) Plot

                                                                                                        func (h *H2D) Plot(c draw.Canvas, p *plot.Plot)

                                                                                                          Plot implements the Plotter interface, drawing a line that connects each point in the Line.

                                                                                                          type HInfoStyle

                                                                                                          type HInfoStyle uint32
                                                                                                          const (
                                                                                                          	HInfoNone    HInfoStyle = 0
                                                                                                          	HInfoEntries HInfoStyle = 1 << iota
                                                                                                          	HInfoMean
                                                                                                          	HInfoRMS
                                                                                                          	HInfoStdDev
                                                                                                          	HInfoSummary HInfoStyle = HInfoEntries | HInfoMean | HInfoStdDev
                                                                                                          )

                                                                                                          type HInfos

                                                                                                          type HInfos struct {
                                                                                                          	Style HInfoStyle
                                                                                                          }

                                                                                                          type HStack

                                                                                                          type HStack struct {
                                                                                                          
                                                                                                          	// LogY allows rendering with a log-scaled Y axis.
                                                                                                          	// When enabled, histogram bins with no entries will be discarded from
                                                                                                          	// the histogram's DataRange.
                                                                                                          	// The lowest Y value for the DataRange will be corrected to leave an
                                                                                                          	// arbitrary amount of height for the smallest bin entry so it is visible
                                                                                                          	// on the final plot.
                                                                                                          	LogY bool
                                                                                                          
                                                                                                          	// Stack specifies how histograms are displayed.
                                                                                                          	// Default is to display histograms stacked on top of each other.
                                                                                                          	// If not stacked, individual histogram uncertainty bands will be
                                                                                                          	// displayed when defined.
                                                                                                          	// If stacked, individual uncertainty bands will not be diplayed
                                                                                                          	// but the total band can be displayed with the hplot.WithBand(true)
                                                                                                          	// option.
                                                                                                          	Stack HStackKind
                                                                                                          
                                                                                                          	// Band displays a colored band between the y-min and y-max error bars.
                                                                                                          	// Error bars are computed as the bin-by-bin quadratic sum of individual
                                                                                                          	// histogram uncertainties.
                                                                                                          	Band *BinnedErrBand
                                                                                                          	// contains filtered or unexported fields
                                                                                                          }

                                                                                                            HStack implements the plot.Plotter interface, drawing a stack of histograms.

                                                                                                            Example
                                                                                                            Output:
                                                                                                            
                                                                                                            
                                                                                                            Example (WithBand)
                                                                                                            Output:
                                                                                                            
                                                                                                            
                                                                                                            Example (WithLogY)
                                                                                                            Output:
                                                                                                            
                                                                                                            

                                                                                                            func NewHStack

                                                                                                            func NewHStack(histos []*H1D, opts ...Options) *HStack

                                                                                                              NewHStack creates a new histogram stack from the provided list of histograms. NewHStack panicks if the list of histograms is empty. NewHStack panicks if the histograms have different binning.

                                                                                                              func (*HStack) DataRange

                                                                                                              func (hstack *HStack) DataRange() (xmin, xmax, ymin, ymax float64)

                                                                                                                DataRange returns the minimum and maximum X and Y values

                                                                                                                func (*HStack) Plot

                                                                                                                func (hstack *HStack) Plot(c draw.Canvas, p *plot.Plot)

                                                                                                                  Plot implements the Plotter interface, drawing a line that connects each point in the Line.

                                                                                                                  type HStackKind

                                                                                                                  type HStackKind int

                                                                                                                    HStackKind customizes how a HStack should behave.

                                                                                                                    const (
                                                                                                                    	// HStackOn instructs HStack to display histograms
                                                                                                                    	// stacked on top of each other.
                                                                                                                    	HStackOn HStackKind = iota
                                                                                                                    	// HStackOff instructs HStack to display histograms
                                                                                                                    	// with the stack disabled.
                                                                                                                    	HStackOff
                                                                                                                    )

                                                                                                                    type HorizLine

                                                                                                                    type HorizLine struct {
                                                                                                                    	Y      float64
                                                                                                                    	Line   draw.LineStyle
                                                                                                                    	Top    color.Color
                                                                                                                    	Bottom color.Color
                                                                                                                    }

                                                                                                                      HorizLine draws a horizontal line at Y and colors the top and bottom portions of the plot with the provided colors.

                                                                                                                      func HLine

                                                                                                                      func HLine(y float64, top, bottom color.Color) *HorizLine

                                                                                                                        HLine creates a horizontal line at y with the default line style.

                                                                                                                        Example

                                                                                                                          An example of making a horizontal-line plot

                                                                                                                          Output:
                                                                                                                          
                                                                                                                          

                                                                                                                          func (*HorizLine) Plot

                                                                                                                          func (hline *HorizLine) Plot(c draw.Canvas, plt *plot.Plot)

                                                                                                                          func (*HorizLine) Thumbnail

                                                                                                                          func (hline *HorizLine) Thumbnail(c *draw.Canvas)

                                                                                                                            Thumbnail returns the thumbnail for the VertLine, implementing the plot.Thumbnailer interface.

                                                                                                                            type Label

                                                                                                                            type Label struct {
                                                                                                                            	Text      string         // Text of the label
                                                                                                                            	X, Y      float64        // Position of the label
                                                                                                                            	TextStyle draw.TextStyle // Text style of the label
                                                                                                                            
                                                                                                                            	// Normalized indicates whether the label position
                                                                                                                            	// is in data coordinates or normalized with regard
                                                                                                                            	// to the canvas space.
                                                                                                                            	// When normalized, the label position is assumed
                                                                                                                            	// to fall in the [0, 1] interval. If true, NewLabel
                                                                                                                            	// panics if x or y are outside [0, 1].
                                                                                                                            	//
                                                                                                                            	// Normalized is false by default.
                                                                                                                            	Normalized bool
                                                                                                                            
                                                                                                                            	// AutoAdjust enables auto adjustment of the label
                                                                                                                            	// position, when Normalized is true and when x
                                                                                                                            	// and/or y are close to 1 and the label is partly
                                                                                                                            	// outside the canvas. If false and the label doesn't
                                                                                                                            	// fit in the canvas, an error is returned.
                                                                                                                            	//
                                                                                                                            	// AutoAdjust is false by default.
                                                                                                                            	AutoAdjust bool
                                                                                                                            	// contains filtered or unexported fields
                                                                                                                            }

                                                                                                                              Label displays a user-defined text string on a plot.

                                                                                                                              Fields of Label should not be modified once the Label has been added to an hplot.Plot.

                                                                                                                              Example
                                                                                                                              Output:
                                                                                                                              
                                                                                                                              

                                                                                                                              func NewLabel

                                                                                                                              func NewLabel(x, y float64, txt string, opts ...LabelOption) *Label

                                                                                                                                NewLabel creates a new txt label at position (x, y).

                                                                                                                                func (*Label) DataRange

                                                                                                                                func (lbl *Label) DataRange() (xmin, xmax, ymin, ymax float64)

                                                                                                                                  DataRange returns the minimum and maximum x and y values, implementing the plot.DataRanger interface.

                                                                                                                                  func (*Label) GlyphBoxes

                                                                                                                                  func (lbl *Label) GlyphBoxes(p *plot.Plot) []plot.GlyphBox

                                                                                                                                    GlyphBoxes returns a GlyphBox, corresponding to the label. GlyphBoxes implements the plot.GlyphBoxer interface.

                                                                                                                                    func (*Label) Plot

                                                                                                                                    func (lbl *Label) Plot(c draw.Canvas, p *plot.Plot)

                                                                                                                                      Plot implements the Plotter interface, drawing the label on the canvas.

                                                                                                                                      type LabelOption

                                                                                                                                      type LabelOption func(cfg *labelConfig)

                                                                                                                                        LabelOption handles various options to configure a Label.

                                                                                                                                        func WithLabelAutoAdjust

                                                                                                                                        func WithLabelAutoAdjust(auto bool) LabelOption

                                                                                                                                          WithLabelAutoAdjust specifies whether the coordinates are automatically adjusted to the canvas size.

                                                                                                                                          func WithLabelNormalized

                                                                                                                                          func WithLabelNormalized(norm bool) LabelOption

                                                                                                                                            WithLabelNormalized specifies whether the coordinates are normalized to the canvas size.

                                                                                                                                            func WithLabelTextStyle

                                                                                                                                            func WithLabelTextStyle(style draw.TextStyle) LabelOption

                                                                                                                                              WithLabelTextStyle specifies the text style of the label.

                                                                                                                                              type NoTicks

                                                                                                                                              type NoTicks struct{}

                                                                                                                                                NoTicks implements plot.Ticker but does not display any tick.

                                                                                                                                                func (NoTicks) Ticks

                                                                                                                                                func (NoTicks) Ticks(min, max float64) []plot.Tick

                                                                                                                                                  Ticks returns Ticks in a specified range

                                                                                                                                                  type Options

                                                                                                                                                  type Options func(cfg *config)

                                                                                                                                                    Options encodes various options to pass to a plot.

                                                                                                                                                    func WithBand

                                                                                                                                                    func WithBand(v bool) Options

                                                                                                                                                      WithBand enables or disables the display of a colored band between Y-error bars.

                                                                                                                                                      func WithGlyphStyle

                                                                                                                                                      func WithGlyphStyle(sty draw.GlyphStyle) Options

                                                                                                                                                        WithGlyphStyle sets the glyph style of a plotter.

                                                                                                                                                        func WithHInfo

                                                                                                                                                        func WithHInfo(v HInfoStyle) Options

                                                                                                                                                          WithHInfo sets a given histogram info style.

                                                                                                                                                          func WithLogY

                                                                                                                                                          func WithLogY(v bool) Options

                                                                                                                                                            WithLogY sets whether the plotter in Y should handle log-scale.

                                                                                                                                                            func WithStepsKind

                                                                                                                                                            func WithStepsKind(s StepsKind) Options

                                                                                                                                                              WithStepsKind sets the style of the connecting line (NoSteps, HiSteps, etc...)

                                                                                                                                                              func WithXErrBars

                                                                                                                                                              func WithXErrBars(v bool) Options

                                                                                                                                                                WithXErrBars enables or disables the display of X-error bars.

                                                                                                                                                                func WithYErrBars

                                                                                                                                                                func WithYErrBars(v bool) Options

                                                                                                                                                                  WithYErrBars enables or disables the display of Y-error bars.

                                                                                                                                                                  type Plot

                                                                                                                                                                  type Plot struct {
                                                                                                                                                                  	*plot.Plot
                                                                                                                                                                  	Style Style
                                                                                                                                                                  }

                                                                                                                                                                    Plot is the basic type representing a plot.

                                                                                                                                                                    func New

                                                                                                                                                                    func New() *Plot

                                                                                                                                                                      New returns a new plot with some reasonable default settings.

                                                                                                                                                                      func (*Plot) Add

                                                                                                                                                                      func (p *Plot) Add(ps ...plot.Plotter)

                                                                                                                                                                        Add adds a Plotters to the plot.

                                                                                                                                                                        If the plotters implements DataRanger then the minimum and maximum values of the X and Y axes are changed if necessary to fit the range of the data.

                                                                                                                                                                        When drawing the plot, Plotters are drawn in the order in which they were added to the plot.

                                                                                                                                                                        func (*Plot) Draw

                                                                                                                                                                        func (p *Plot) Draw(dc draw.Canvas)

                                                                                                                                                                          Draw draws a plot to a draw.Canvas.

                                                                                                                                                                          Plotters are drawn in the order in which they were added to the plot. Plotters that implement the GlyphBoxer interface will have their GlyphBoxes taken into account when padding the plot so that none of their glyphs are clipped.

                                                                                                                                                                          func (*Plot) Save

                                                                                                                                                                          func (p *Plot) Save(w, h vg.Length, file string) error

                                                                                                                                                                            Save saves the plot to an image file. The file format is determined by the extension.

                                                                                                                                                                            Supported extensions are:

                                                                                                                                                                            .eps, .jpg, .jpeg, .pdf, .png, .svg, .tex, .tif and .tiff.
                                                                                                                                                                            

                                                                                                                                                                            If w or h are <= 0, the value is chosen such that it follows the Golden Ratio. If w and h are <= 0, the values are chosen such that they follow the Golden Ratio (the width is defaulted to vgimg.DefaultWidth).

                                                                                                                                                                            func (*Plot) WriterTo

                                                                                                                                                                            func (p *Plot) WriterTo(w, h vg.Length, format string) (io.WriterTo, error)

                                                                                                                                                                              WriterTo returns an io.WriterTo that will write the plot as the specified image format.

                                                                                                                                                                              Supported formats are:

                                                                                                                                                                              eps, jpg|jpeg, pdf, png, svg, tex and tif|tiff.
                                                                                                                                                                              

                                                                                                                                                                              type RatioPlot

                                                                                                                                                                              type RatioPlot struct {
                                                                                                                                                                              	Top    *Plot
                                                                                                                                                                              	Bottom *Plot
                                                                                                                                                                              
                                                                                                                                                                              	// Tiles controls the layout of the 2x1 ratio-plot grid.
                                                                                                                                                                              	// Tiles can be used to customize the padding between plots.
                                                                                                                                                                              	Tiles draw.Tiles
                                                                                                                                                                              
                                                                                                                                                                              	// Ratio controls how the vertical space is partioned between
                                                                                                                                                                              	// the top and bottom plots.
                                                                                                                                                                              	// The top plot will take (1-ratio)*height.
                                                                                                                                                                              	// Default is 0.3.
                                                                                                                                                                              	Ratio float64
                                                                                                                                                                              }
                                                                                                                                                                              Example
                                                                                                                                                                              Output:
                                                                                                                                                                              
                                                                                                                                                                              

                                                                                                                                                                              func NewRatioPlot

                                                                                                                                                                              func NewRatioPlot() *RatioPlot

                                                                                                                                                                              func (*RatioPlot) Draw

                                                                                                                                                                              func (rp *RatioPlot) Draw(dc draw.Canvas)

                                                                                                                                                                                Draw draws a ratio plot to a draw.Canvas.

                                                                                                                                                                                Plotters are drawn in the order in which they were added to the plot. Plotters that implement the GlyphBoxer interface will have their GlyphBoxes taken into account when padding the plot so that none of their glyphs are clipped.

                                                                                                                                                                                type S2D

                                                                                                                                                                                type S2D struct {
                                                                                                                                                                                	Data plotter.XYer
                                                                                                                                                                                
                                                                                                                                                                                	// GlyphStyle is the style of the glyphs drawn
                                                                                                                                                                                	// at each point.
                                                                                                                                                                                	draw.GlyphStyle
                                                                                                                                                                                
                                                                                                                                                                                	// LineStyle is the style of the line drawn
                                                                                                                                                                                	// connecting each point.
                                                                                                                                                                                	// Use zero width to disable.
                                                                                                                                                                                	LineStyle draw.LineStyle
                                                                                                                                                                                
                                                                                                                                                                                	// XErrs is the x error bars plotter.
                                                                                                                                                                                	XErrs *plotter.XErrorBars
                                                                                                                                                                                
                                                                                                                                                                                	// YErrs is the y error bars plotter.
                                                                                                                                                                                	YErrs *plotter.YErrorBars
                                                                                                                                                                                
                                                                                                                                                                                	// Band displays a colored band between the y-min and y-max error bars.
                                                                                                                                                                                	Band *Band
                                                                                                                                                                                
                                                                                                                                                                                	// Steps controls the style of the connecting
                                                                                                                                                                                	// line (NoSteps, HiSteps, etc...)
                                                                                                                                                                                	Steps StepsKind
                                                                                                                                                                                }

                                                                                                                                                                                  S2D plots a set of 2-dim points with error bars.

                                                                                                                                                                                  Example

                                                                                                                                                                                    ExampleS2D draws some scatter points.

                                                                                                                                                                                    Output:
                                                                                                                                                                                    
                                                                                                                                                                                    
                                                                                                                                                                                    Example (WithBand)

                                                                                                                                                                                      ExampleS2D_withBand draws some scatter points with their error bars and a band

                                                                                                                                                                                      Output:
                                                                                                                                                                                      
                                                                                                                                                                                      
                                                                                                                                                                                      Example (WithErrorBars)

                                                                                                                                                                                        ExampleS2D_withErrorBars draws some scatter points with their error bars.

                                                                                                                                                                                        Output:
                                                                                                                                                                                        
                                                                                                                                                                                        
                                                                                                                                                                                        Example (WithStepsKind)

                                                                                                                                                                                          ExampleS2D_withStepsKind draws some scatter points with their error bars, using a step-like style

                                                                                                                                                                                          Output:
                                                                                                                                                                                          
                                                                                                                                                                                          
                                                                                                                                                                                          Example (WithStepsKind_withBand)

                                                                                                                                                                                            ExampleS2D_withSteps_withBand draws some scatter points with their error bars, using a step-like style together with a band

                                                                                                                                                                                            Output:
                                                                                                                                                                                            
                                                                                                                                                                                            

                                                                                                                                                                                            func NewS2D

                                                                                                                                                                                            func NewS2D(data plotter.XYer, opts ...Options) *S2D

                                                                                                                                                                                              NewS2D creates a 2-dim scatter plot from a XYer.

                                                                                                                                                                                              func (*S2D) DataRange

                                                                                                                                                                                              func (pts *S2D) DataRange() (xmin, xmax, ymin, ymax float64)

                                                                                                                                                                                                DataRange returns the minimum and maximum x and y values, implementing the plot.DataRanger interface.

                                                                                                                                                                                                func (*S2D) GlyphBoxes

                                                                                                                                                                                                func (pts *S2D) GlyphBoxes(plt *plot.Plot) []plot.GlyphBox

                                                                                                                                                                                                  GlyphBoxes returns a slice of plot.GlyphBoxes, implementing the plot.GlyphBoxer interface.

                                                                                                                                                                                                  func (*S2D) Plot

                                                                                                                                                                                                  func (pts *S2D) Plot(c draw.Canvas, plt *plot.Plot)

                                                                                                                                                                                                    Plot draws the Scatter, implementing the plot.Plotter interface.

                                                                                                                                                                                                    func (*S2D) Thumbnail

                                                                                                                                                                                                    func (pts *S2D) Thumbnail(c *draw.Canvas)

                                                                                                                                                                                                      Thumbnail the thumbnail for the Scatter, implementing the plot.Thumbnailer interface.

                                                                                                                                                                                                      type StepsKind

                                                                                                                                                                                                      type StepsKind byte

                                                                                                                                                                                                        Step kind

                                                                                                                                                                                                        const (
                                                                                                                                                                                                        	NoSteps StepsKind = iota
                                                                                                                                                                                                        	HiSteps
                                                                                                                                                                                                        )

                                                                                                                                                                                                        type Style

                                                                                                                                                                                                        type Style struct {
                                                                                                                                                                                                        	Fonts struct {
                                                                                                                                                                                                        		Name   string  // font name of this style
                                                                                                                                                                                                        		Title  vg.Font // font used for the plot title
                                                                                                                                                                                                        		Label  vg.Font // font used for the plot labels
                                                                                                                                                                                                        		Legend vg.Font // font used for the plot legend
                                                                                                                                                                                                        		Tick   vg.Font // font used for the plot's axes' ticks
                                                                                                                                                                                                        	}
                                                                                                                                                                                                        }

                                                                                                                                                                                                          Style stores a given plot style.

                                                                                                                                                                                                          var (
                                                                                                                                                                                                          	// DefaultStyle is the default style used for hplot plots.
                                                                                                                                                                                                          	DefaultStyle Style
                                                                                                                                                                                                          )

                                                                                                                                                                                                          func NewStyle

                                                                                                                                                                                                          func NewStyle(name string, ft *truetype.Font) (Style, error)

                                                                                                                                                                                                            NewStyle creates a new style with the given truetype font.

                                                                                                                                                                                                            func (*Style) Apply

                                                                                                                                                                                                            func (s *Style) Apply(p *Plot)

                                                                                                                                                                                                              Apply setups the plot p with the current style.

                                                                                                                                                                                                              type Ticks

                                                                                                                                                                                                              type Ticks struct {
                                                                                                                                                                                                              	N int // N is the suggested number of major ticks to display.
                                                                                                                                                                                                              
                                                                                                                                                                                                              	// Format is an optional major-tick formatter.
                                                                                                                                                                                                              	// If empty, a format will be automatically chosen.
                                                                                                                                                                                                              	Format string
                                                                                                                                                                                                              }

                                                                                                                                                                                                                Ticks implements plot.Ticker. Ticks allows to specify the maximum number of major ticks to display. The zero value of Ticks display a maximum number of 3 major ticks.

                                                                                                                                                                                                                Example
                                                                                                                                                                                                                Output:
                                                                                                                                                                                                                
                                                                                                                                                                                                                

                                                                                                                                                                                                                func (Ticks) Ticks

                                                                                                                                                                                                                func (tck Ticks) Ticks(min, max float64) []plot.Tick

                                                                                                                                                                                                                type TiledPlot

                                                                                                                                                                                                                type TiledPlot struct {
                                                                                                                                                                                                                	Plots []*Plot
                                                                                                                                                                                                                	Tiles draw.Tiles
                                                                                                                                                                                                                	Align bool // whether to align all tiles axes
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  TiledPlot is a regularly spaced set of plots, aranged as tiles.

                                                                                                                                                                                                                  Example

                                                                                                                                                                                                                    An example of making a tile-plot

                                                                                                                                                                                                                    Output:
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    Example (Align)

                                                                                                                                                                                                                      An example of making aligned tile-plots

                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      

                                                                                                                                                                                                                      func NewTiledPlot

                                                                                                                                                                                                                      func NewTiledPlot(tiles draw.Tiles) *TiledPlot

                                                                                                                                                                                                                        NewTiledPlot creates a new set of plots aranged as tiles. By default, NewTiledPlot will put a 1 vg.Length space between each plot.

                                                                                                                                                                                                                        func (*TiledPlot) Draw

                                                                                                                                                                                                                        func (tp *TiledPlot) Draw(c draw.Canvas)

                                                                                                                                                                                                                          Draw draws the tiled plot to a draw.Canvas.

                                                                                                                                                                                                                          Each non-nil plot.Plot in the aranged set of tiled plots is drawn inside its dedicated sub-canvas, using hplot.Plot.Draw.

                                                                                                                                                                                                                          func (*TiledPlot) Plot

                                                                                                                                                                                                                          func (tp *TiledPlot) Plot(i, j int) *Plot

                                                                                                                                                                                                                            Plot returns the plot at the i-th column and j-th row in the set of tiles. (0,0) is at the top-left of the set of tiles.

                                                                                                                                                                                                                            func (*TiledPlot) Save

                                                                                                                                                                                                                            func (tp *TiledPlot) Save(w, h vg.Length, file string) error

                                                                                                                                                                                                                              Save saves the plots to an image file. The file format is determined by the extension.

                                                                                                                                                                                                                              Supported extensions are the same ones than hplot.Plot.Save.

                                                                                                                                                                                                                              If w or h are <= 0, the value is chosen such that it follows the Golden Ratio. If w and h are <= 0, the values are chosen such that they follow the Golden Ratio (the width is defaulted to vgimg.DefaultWidth).

                                                                                                                                                                                                                              type VertLine

                                                                                                                                                                                                                              type VertLine struct {
                                                                                                                                                                                                                              	X     float64
                                                                                                                                                                                                                              	Line  draw.LineStyle
                                                                                                                                                                                                                              	Left  color.Color
                                                                                                                                                                                                                              	Right color.Color
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                VertLine draws a vertical line at X and colors the left and right portions of the plot with the provided colors.

                                                                                                                                                                                                                                func VLine

                                                                                                                                                                                                                                func VLine(x float64, left, right color.Color) *VertLine

                                                                                                                                                                                                                                  VLine creates a vertical line at x with the default line style.

                                                                                                                                                                                                                                  Example

                                                                                                                                                                                                                                    An example of making a vertical-line plot

                                                                                                                                                                                                                                    Output:
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                    func (*VertLine) Plot

                                                                                                                                                                                                                                    func (vline *VertLine) Plot(c draw.Canvas, plt *plot.Plot)

                                                                                                                                                                                                                                    func (*VertLine) Thumbnail

                                                                                                                                                                                                                                    func (vline *VertLine) Thumbnail(c *draw.Canvas)

                                                                                                                                                                                                                                      Thumbnail returns the thumbnail for the VertLine, implementing the plot.Thumbnailer interface.

                                                                                                                                                                                                                                      Directories

                                                                                                                                                                                                                                      Path Synopsis
                                                                                                                                                                                                                                      cmd
                                                                                                                                                                                                                                      hplot
                                                                                                                                                                                                                                      hplot is a simple gnuplot-like command to create plots
                                                                                                                                                                                                                                      hplot is a simple gnuplot-like command to create plots
                                                                                                                                                                                                                                      internal