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 ¶
- func NewGrid() *plotter.Grid
- func NewLine(xys plotter.XYer) (*plotter.Line, error)
- func NewScatter(xys plotter.XYer) (*plotter.Scatter, error)
- func Show(p *Plot, w, h vg.Length, format string) ([]byte, error)
- func ZipXY(x, y []float64) plotter.XYer
- type Band
- type FreqTicks
- type Function
- type H1D
- type H2D
- type HInfoStyle
- type HInfos
- type HorizLine
- type NoTicks
- type Options
- type Plot
- type S2D
- type Style
- type TiledPlot
- func (tp *TiledPlot) Draw(c draw.Canvas)
- func (tp *TiledPlot) Plot(i, j int) *Plot
- func (tp *TiledPlot) Save(w, h vg.Length, file string) (err error)
- func (tp *TiledPlot) Show(w, h vg.Length, scr screen.Screen) (*vgshiny.Canvas, error)
- func (tp *TiledPlot) WriterTo(w, h vg.Length, format string) (io.WriterTo, error)
- type VertLine
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func NewGrid ¶
NewGrid returns a new grid with both vertical and horizontal lines using the default grid line style.
func NewScatter ¶
NewScatter returns a Scatter that uses the default glyph style.
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:
type FreqTicks ¶
FreqTicks implements a simple plot.Ticker scheme. FreqTicks will generate N ticks where 1 every Freq tick will be labeled.
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 ¶
NewFunction returns a Function that plots F using the default line style with 50 samples.
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 ¶
NewH1D returns a new histogram, as in NewH1DFromXYer, except that it accepts a hbook.H1D instead of a plotter.XYer
func NewH1FromValuer ¶
NewH1FromValuer returns a new histogram, as in NewH1FromXYer, except that it accepts a plotter.Valuer instead of an XYer.
func NewH1FromXYer ¶
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) GlyphBoxes ¶
GlyphBoxes returns a slice of GlyphBoxes, one for each of the bins, implementing the plot.GlyphBoxer interface.
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 (*H2D) GlyphBoxes ¶
GlyphBoxes returns a slice of GlyphBoxes, one for each of the bins, implementing the plot.GlyphBoxer interface.
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
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
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:
type Plot ¶
Plot is the basic type representing a plot.
func (*Plot) Add ¶
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 ¶
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).
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 (*S2D) DataRange ¶
DataRange returns the minimum and maximum x and y values, implementing the plot.DataRanger interface.
func (*S2D) GlyphBoxes ¶
GlyphBoxes returns a slice of plot.GlyphBoxes, implementing the plot.GlyphBoxer 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 )
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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
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
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: