hplot

package
v0.24.0 Latest Latest
Warning

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

 Go to latest Published: Mar 19, 2020 License: BSD-3-Clause Imports: 23 Imported by: 50

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)
	}
}
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

Diff-plots

diff-plot

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

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

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

Documentation

Overview

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

Example (Diffplot) 
package main

import (
	"image/color"
	"log"
	"math"
	"os"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"golang.org/x/exp/rand"
	"gonum.org/v1/gonum/stat/distuv"
	"gonum.org/v1/plot/vg"
	"gonum.org/v1/plot/vg/draw"
	"gonum.org/v1/plot/vg/vgimg"
)

func main() {

	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()
		v2 := dist.Rand() + 0.5
		hist1.Fill(v1, 1)
		hist2.Fill(v2, 1)
	}

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

	// Create a histogram of our values drawn
	// from the standard normal.
	h1 := hplot.NewH1D(hist1)
	h1.LineStyle.Color = color.RGBA{R: 255, A: 255}
	h1.FillColor = nil
	p1.Add(h1)

	h2 := hplot.NewH1D(hist2)
	h2.LineStyle.Color = color.RGBA{B: 255, A: 255}
	h2.FillColor = nil
	p1.Add(h2)

	// hide X-axis labels
	p1.X.Tick.Marker = hplot.NoTicks{}

	p1.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)

	p2 := hplot.New()
	p2.X.Label.Text = "X"
	p2.Y.Label.Text = "Delta-Y"
	p2.Add(hdiff)
	p2.Add(hplot.NewGrid())

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

	c := vgimg.PngCanvas{Canvas: vgimg.New(width, height)}
	dc := draw.New(c)
	top := draw.Canvas{
		Canvas: dc,
		Rectangle: vg.Rectangle{
			Min: vg.Point{X: 0, Y: 0.3 * height},
			Max: vg.Point{X: width, Y: height},
		},
	}
	p1.Draw(top)

	bottom := draw.Canvas{
		Canvas: dc,
		Rectangle: vg.Rectangle{
			Min: vg.Point{X: 0, Y: 0},
			Max: vg.Point{X: width, Y: 0.3 * height},
		},
	}
	p2.Draw(bottom)

	f, err := os.Create("testdata/diff_plot.png")
	if err != nil {
		log.Fatalf("error: %v\n", err)
	}
	defer f.Close()
	_, err = c.WriteTo(f)
	if err != nil {
		log.Fatal(err)
	}
	err = f.Close()
	if err != nil {
		log.Fatal(err)
	}
}

Output:
Example (Latexplot) 
package main

import (
	"image/color"
	"log"
	"math"
	"os"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"golang.org/x/exp/rand"
	"gonum.org/v1/gonum/stat/distuv"
	"gonum.org/v1/plot/vg"
	"gonum.org/v1/plot/vg/draw"
	"gonum.org/v1/plot/vg/vgtex"
)

func main() {

	const npoints = 10000

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

	hist := hbook.NewH1D(20, -4, +4)
	for i := 0; i < npoints; i++ {
		v := dist.Rand()
		hist.Fill(v, 1)
	}

	// Make a plot and set its title.
	p := hplot.New()
	p.Title.Text = `Gaussian distribution: $f(x) = \frac{e^{-(x - \mu)^{2}/(2\sigma^{2}) }} {\sigma\sqrt{2\pi}}$`
	p.Y.Label.Text = `$f(x)$`
	p.X.Label.Text = `$x$`

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

	p.Add(hplot.NewGrid())

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

	c := vgtex.NewDocument(width, height)
	p.Draw(draw.New(c))
	f, err := os.Create("testdata/latex_plot.tex")
	if err != nil {
		log.Fatalf("error: %v\n", err)
	}
	defer f.Close()
	_, err = c.WriteTo(f)
	if err != nil {
		log.Fatal(err)
	}
	err = f.Close()
	if err != nil {
		log.Fatal(err)
	}
}

Output:
Example (Subplot)

An example of a plot + sub-plot 

package main

import (
	"image/color"
	"log"
	"math"
	"os"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"golang.org/x/exp/rand"
	"gonum.org/v1/gonum/stat/distuv"
	"gonum.org/v1/plot/vg"
	"gonum.org/v1/plot/vg/draw"
	"gonum.org/v1/plot/vg/vgimg"
)

func main() {
	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 histo
	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.
	p1 := hplot.New()
	p1.Title.Text = "Histogram"
	p1.X.Label.Text = "X"
	p1.Y.Label.Text = "Y"

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

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

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

	// make a second plot which will be diplayed in the upper-right
	// of the previous one
	p2 := hplot.New()
	p2.Title.Text = "Sub plot"
	p2.Add(h)
	p2.Add(hplot.NewGrid())

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

	c := vgimg.PngCanvas{Canvas: vgimg.New(width, height)}
	dc := draw.New(c)
	p1.Draw(dc)
	sub := draw.Canvas{
		Canvas: dc,
		Rectangle: vg.Rectangle{
			Min: vg.Point{X: 0.70 * width, Y: 0.50 * height},
			Max: vg.Point{X: 1.00 * width, Y: 1.00 * height},
		},
	}
	p2.Draw(sub)

	f, err := os.Create("testdata/sub_plot.png")
	if err != nil {
		log.Fatalf("error: %v\n", err)
	}
	defer f.Close()
	_, err = c.WriteTo(f)
	if err != nil {
		log.Fatal(err)
	}
	err = f.Close()
	if err != nil {
		log.Fatal(err)
	}

}

Output:

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

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 Show 

func Show(p *Plot, 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 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 added in v0.20.0 

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 

package main

import (
	"image/color"
	"log"
	"math"

	"go-hep.org/x/hep/hplot"
	"golang.org/x/exp/rand"
	"gonum.org/v1/gonum/stat/distuv"
	"gonum.org/v1/plot/plotter"
	"gonum.org/v1/plot/vg"
	"gonum.org/v1/plot/vg/draw"
)

func main() {
	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)
	}
}

Output:

func NewBand added in v0.20.0 

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

func (*Band) DataRange added in v0.20.0 

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 added in v0.20.0 

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

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 added in v0.21.0 

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. 

package main

import (
	"image/color"
	"log"
	"math"

	"go-hep.org/x/hep/hplot"
	"gonum.org/v1/plot/vg"
)

func main() {
	quad := hplot.NewFunction(func(x float64) float64 { return x * x })
	quad.Color = color.RGBA{B: 255, A: 255}

	exp := hplot.NewFunction(func(x float64) float64 { return math.Pow(2, x) })
	exp.Dashes = []vg.Length{vg.Points(2), vg.Points(2)}
	exp.Width = vg.Points(2)
	exp.Color = color.RGBA{G: 255, A: 255}

	sin := hplot.NewFunction(func(x float64) float64 { return 10*math.Sin(x) + 50 })
	sin.Dashes = []vg.Length{vg.Points(4), vg.Points(5)}
	sin.Width = vg.Points(4)
	sin.Color = color.RGBA{R: 255, A: 255}

	p := hplot.New()
	p.Title.Text = "Functions"
	p.X.Label.Text = "X"
	p.Y.Label.Text = "Y"

	p.Add(quad, exp, sin)
	p.Legend.Add("x^2", quad)
	p.Legend.Add("2^x", exp)
	p.Legend.Add("10*sin(x)+50", sin)
	p.Legend.ThumbnailWidth = 0.5 * vg.Inch

	p.X.Min = 0
	p.X.Max = 10
	p.Y.Min = 0
	p.Y.Max = 100

	err := p.Save(200, 200, "testdata/functions.png")
	if err != nil {
		log.Panic(err)
	}
}

Output:
Example (LogY)

ExampleFunction_logY draws a function with a Log-Y axis. 

package main

import (
	"image/color"
	"log"

	"go-hep.org/x/hep/hplot"
	"gonum.org/v1/plot"
	"gonum.org/v1/plot/vg"
)

func main() {
	quad := hplot.NewFunction(func(x float64) float64 { return x * x })
	quad.Color = color.RGBA{B: 255, A: 255}

	fun := hplot.NewFunction(func(x float64) float64 {
		switch {
		case x < 6:
			return 20
		case 6 <= x && x < 7:
			return 0
		case 7 <= x && x < 7.5:
			return 30
		case 7.5 <= x && x < 9:
			return 0
		case 9 <= x:
			return 40
		}
		return 50
	})
	fun.LogY = true
	fun.Color = color.RGBA{R: 255, A: 255}

	p := hplot.New()
	p.Title.Text = "Functions - Log-Y scale"
	p.X.Label.Text = "X"
	p.Y.Label.Text = "Y"

	p.Y.Scale = plot.LogScale{}
	p.Y.Tick.Marker = plot.LogTicks{}

	p.Add(fun)
	p.Add(quad)
	p.Add(hplot.NewGrid())
	p.Legend.Add("x^2", quad)
	p.Legend.Add("fct", fun)
	p.Legend.ThumbnailWidth = 0.5 * vg.Inch

	p.X.Min = 5
	p.X.Max = 10
	p.Y.Min = 10
	p.Y.Max = 100

	err := p.Save(200, 200, "testdata/functions_logy.png")
	if err != nil {
		log.Panic(err)
	}
}

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 added in v0.21.0 

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 added in v0.21.0 

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

	// 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
}

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

Example

An example of making a 1D-histogram. 

package main

import (
	"image/color"
	"log"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"golang.org/x/exp/rand"
	"gonum.org/v1/gonum/stat/distuv"
	"gonum.org/v1/plot/vg"
)

func main() {
	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)
	}
}

Output:
Example (LogScaleY) 
package main

import (
	"image/color"
	"log"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"gonum.org/v1/plot"
	"gonum.org/v1/plot/vg"
)

func main() {
	p := hplot.New()
	p.Title.Text = "Histogram in log-y"
	p.Y.Scale = plot.LogScale{}
	p.Y.Tick.Marker = plot.LogTicks{}
	p.Y.Label.Text = "Y"
	p.X.Label.Text = "X"

	h1 := hbook.NewH1D(10, -5, +5)
	for _, v := range []float64{
		-2, -2,
		-1,
		+3, +3, +3, +3,
		+1, +1, +1, +1, +1, +1, +1, +1, +1, +1,
		+1, +1, +1, +1, +1, +1, +1, +1, +1, +1,
	} {
		h1.Fill(v, 1)
	}
	p1 := hplot.NewH1D(h1)
	p1.LogY = true
	p1.FillColor = color.RGBA{255, 0, 0, 255}

	h2 := hbook.NewH1D(10, -5, +5)
	for _, v := range []float64{
		-3, -3, -3,
		+2, +2, +2, +2, +2,
	} {
		h2.Fill(v, 1)
	}
	p2 := hplot.NewH1D(h2)
	p2.LogY = true
	p2.FillColor = color.RGBA{0, 0, 255, 255}

	p.Add(p1, p2, hplot.NewGrid())

	err := p.Save(6*vg.Inch, -1, "testdata/h1d_logy.png")
	if err != nil {
		log.Fatal(err)
	}
}

Output:
Example (ToPDF)

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

package main

import (
	"image/color"
	"log"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"golang.org/x/exp/rand"
	"gonum.org/v1/gonum/stat/distuv"
	"gonum.org/v1/plot/vg"
)

func main() {
	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.pdf"); err != nil {
		log.Fatalf("error saving plot: %v\n", err)
	}
}

Output:

func NewH1D 

func NewH1D(h *hbook.H1D) *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) *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) *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 
package main

import (
	"log"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"golang.org/x/exp/rand"
	"gonum.org/v1/gonum/mat"
	"gonum.org/v1/gonum/stat/distmv"
	"gonum.org/v1/plot/plotter"
	"gonum.org/v1/plot/vg"
)

func main() {
	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)
	}
}

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 HorizLine added in v0.20.0 

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 added in v0.20.0 

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 

package main

import (
	"image/color"
	"log"

	"go-hep.org/x/hep/hplot"
	"gonum.org/v1/plot/vg"
)

func main() {
	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)
	}
}

Output:

func (*HorizLine) Plot added in v0.20.0 

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

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 int32

Options encodes various options to pass to a plot. 

const (
	OptNone      Options = 1 << iota // default
	WithXErrBars                     // enable display of X-error bars (if available)
	WithYErrBars                     // enable display of Y-error bars (if available)
	WithBand                         // enable display of a colored band between Y-error bars (if available)
)

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) Save 

func (p *Plot) Save(w, h vg.Length, file 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, .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) Show 

func (p *Plot) Show(w, h vg.Length, scr screen.Screen) (*vgshiny.Canvas, error)

Show displays the plot to the screen, with the given dimensions.

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 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

	// Band displays a colored band between the y-min and y-max error bars.
	Band *Band
	// contains filtered or unexported fields
}

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

Example

ExampleS2D draws some scatter points. 

package main

import (
	"image/color"
	"log"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"golang.org/x/exp/rand"
	"gonum.org/v1/gonum/mat"
	"gonum.org/v1/gonum/stat/distmv"
	"gonum.org/v1/plot/plotter"
	"gonum.org/v1/plot/vg"
)

func main() {
	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)
	}
}

Output:
Example (WithBand)

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

package main

import (
	"image/color"
	"log"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"gonum.org/v1/plot/plotter"
	"gonum.org/v1/plot/plotutil"
	"gonum.org/v1/plot/vg"
)

func main() {
	pts := []hbook.Point2D{
		{X: 1, Y: 1, ErrY: hbook.Range{Min: 2, Max: 3}},
		{X: 2, Y: 2, ErrY: hbook.Range{Min: 5, Max: 2}},
		{X: 3, Y: 3, ErrY: hbook.Range{Min: 2, Max: 2}},
		{X: 4, Y: 4, ErrY: hbook.Range{Min: 1.2, Max: 2}},
	}
	s2d := hbook.NewS2D(pts...)

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

	s := hplot.NewS2D(s2d, hplot.WithBand|hplot.WithYErrBars)
	s.GlyphStyle.Color = color.Black
	s.GlyphStyle.Radius = vg.Points(4)
	s.LineStyle.Width = 1
	s.LineStyle.Dashes = plotutil.Dashes(2)

	p.Add(s)

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

Output:
Example (WithErrorBars)

ExampleS2D_withErrorBars draws some scatter points with their error bars. 

package main

import (
	"image/color"
	"log"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"gonum.org/v1/plot/plotter"
	"gonum.org/v1/plot/vg"
)

func main() {
	pts := []hbook.Point2D{
		{X: 1, Y: 1, ErrX: hbook.Range{Min: 0.5, Max: 0.5}, ErrY: hbook.Range{Min: 2, Max: 3}},
		{X: 2, Y: 2, ErrX: hbook.Range{Min: 0.5, Max: 1.5}, ErrY: hbook.Range{Min: 5, Max: 2}},
	}
	s2d := hbook.NewS2D(pts...)

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

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

	p.Add(s)

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

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 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 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 

package main

import (
	"fmt"
	"log"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"golang.org/x/exp/rand"
	"gonum.org/v1/gonum/stat/distuv"
	"gonum.org/v1/plot/vg"
	"gonum.org/v1/plot/vg/draw"
)

func main() {
	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)
	}
}

Output:
Example (Align)

An example of making aligned tile-plots 

package main

import (
	"fmt"
	"image/color"
	"log"
	"math"

	"go-hep.org/x/hep/hbook"
	"go-hep.org/x/hep/hplot"
	"gonum.org/v1/plot/vg"
	"gonum.org/v1/plot/vg/draw"
)

func main() {
	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)
	}
}

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) (err 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).

func (*TiledPlot) Show 

func (tp *TiledPlot) Show(w, h vg.Length, scr screen.Screen) (*vgshiny.Canvas, error)

Show displays the plots to the screen, with the given dimensions.

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 (*TiledPlot) WriterTo 

func (tp *TiledPlot) WriterTo(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).

type VertLine added in v0.20.0 

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 added in v0.20.0 

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 

package main

import (
	"image/color"
	"log"

	"go-hep.org/x/hep/hplot"
	"gonum.org/v1/plot/vg"
)

func main() {
	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)
	}
}

Output:

func (*VertLine) Plot added in v0.20.0 

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

Source Files

View all Source files

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
iplot

Jump to

Keyboard shortcuts

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