// 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 (p *Plot) Draw(c draw.Canvas) { if p.BackgroundColor != nil { c.SetColor(p.BackgroundColor) c.Fill(c.Rectangle.Path()) } if p.Title.Text != "" { c.FillText(p.Title.TextStyle, c.Center().X, c.Max.Y, -0.5, -1, p.Title.Text) c.Max.Y -= p.Title.Height(p.Title.Text) - p.Title.Font.Extents().Descent c.Max.Y -= p.Title.Padding } p.X.sanitizeRange() x := horizontalAxis{p.X} p.Y.sanitizeRange() y := verticalAxis{p.Y} ywidth := y.size() x.draw(padX(p, draw.Crop(c, ywidth, 0, 0, 0))) xheight := x.size() y.draw(padY(p, draw.Crop(c, 0, 0, xheight, 0))) dataC := padY(p, padX(p, draw.Crop(c, ywidth, 0, xheight, 0))) for _, data := range p.plotters { data.Plot(dataC, p) } p.Legend.draw(draw.Crop(draw.Crop(c, ywidth, 0, 0, 0), 0, 0, xheight, 0)) }
// DrawGlyphBoxes draws red outlines around the plot's // GlyphBoxes. This is intended for debugging. func (p *Plot) DrawGlyphBoxes(c *draw.Canvas) { c.SetColor(color.RGBA{R: 255, A: 255}) for _, b := range p.GlyphBoxes(p) { b.Rectangle.Min.X += c.X(b.X) b.Rectangle.Min.Y += c.Y(b.Y) c.Stroke(b.Rectangle.Path()) } }
// Plot implements the Plot method of the plot.Plotter interface. func (h *Contour) Plot(c draw.Canvas, plt *plot.Plot) { if naive { h.naivePlot(c, plt) return } var pal []color.Color if h.Palette != nil { pal = h.Palette.Colors() } trX, trY := plt.Transforms(&c) // Collate contour paths and draw them. // // The alternative naive approach is to draw each line segment as // conrec returns it. The integrated path approach allows graphical // optimisations and is necessary for contour fill shading. cp := contourPaths(h.GridXYZ, h.Levels, trX, trY) // ps is a palette scaling factor to scale the palette uniformly // across the given levels. This enables a discordance between the // number of colours and the number of levels. Sorting is not // necessary since contourPaths sorts the levels as a side effect. ps := float64(len(pal)-1) / (h.Levels[len(h.Levels)-1] - h.Levels[0]) if len(h.Levels) == 1 { ps = 0 } for i, z := range h.Levels { if math.IsNaN(z) { continue } for _, pa := range cp[z] { if isLoop(pa) { pa.Close() } style := h.LineStyles[i%len(h.LineStyles)] var col color.Color switch { case z < h.Min: col = h.Underflow case z > h.Max: col = h.Overflow case len(pal) == 0: col = style.Color default: col = pal[int((z-h.Levels[0])*ps+0.5)] // Apply palette scaling. } if col != nil && style.Width != 0 { c.SetLineStyle(style) c.SetColor(col) c.Stroke(pa) } } } }
// Plot implements the Plot method of the plot.Plotter interface. func (bs *Bubbles) Plot(c draw.Canvas, plt *plot.Plot) { trX, trY := plt.Transforms(&c) c.SetColor(bs.Color) for _, d := range bs.XYZs { x := trX(d.X) y := trY(d.Y) if !c.Contains(draw.Point{x, y}) { continue } rad := bs.radius(d.Z) // draw a circle centered at x, y var p vg.Path p.Move(x+rad, y) p.Arc(x, y, rad, 0, 2*math.Pi) p.Close() c.Fill(p) } }
// Plot draws the Line, implementing the plot.Plotter // interface. func (pts *Line) Plot(c draw.Canvas, plt *plot.Plot) { trX, trY := plt.Transforms(&c) ps := make([]draw.Point, len(pts.XYs)) for i, p := range pts.XYs { ps[i].X = trX(p.X) ps[i].Y = trY(p.Y) } if pts.ShadeColor != nil && len(ps) > 0 { c.SetColor(*pts.ShadeColor) minY := trY(plt.Y.Min) var pa vg.Path pa.Move(ps[0].X, minY) for i := range pts.XYs { pa.Line(ps[i].X, ps[i].Y) } pa.Line(ps[len(pts.XYs)-1].X, minY) pa.Close() c.Fill(pa) } c.StrokeLines(pts.LineStyle, c.ClipLinesXY(ps)...) }
// Plot implements the Plot method of the plot.Plotter interface. func (h *HeatMap) Plot(c draw.Canvas, plt *plot.Plot) { pal := h.Palette.Colors() if len(pal) == 0 { panic("heatmap: empty palette") } // ps scales the palette uniformly across the data range. ps := float64(len(pal)-1) / (h.Max - h.Min) trX, trY := plt.Transforms(&c) var pa vg.Path cols, rows := h.GridXYZ.Dims() for i := 0; i < cols; i++ { var right, left float64 switch i { case 0: right = (h.GridXYZ.X(i+1) - h.GridXYZ.X(i)) / 2 left = -right case cols - 1: right = (h.GridXYZ.X(i) - h.GridXYZ.X(i-1)) / 2 left = -right default: right = (h.GridXYZ.X(i+1) - h.GridXYZ.X(i)) / 2 left = -(h.GridXYZ.X(i) - h.GridXYZ.X(i-1)) / 2 } for j := 0; j < rows; j++ { v := h.GridXYZ.Z(i, j) if math.IsNaN(v) || math.IsInf(v, 0) { continue } pa = pa[:0] var up, down float64 switch j { case 0: up = (h.GridXYZ.Y(j+1) - h.GridXYZ.Y(j)) / 2 down = -up case rows - 1: up = (h.GridXYZ.Y(j) - h.GridXYZ.Y(j-1)) / 2 down = -up default: up = (h.GridXYZ.Y(j+1) - h.GridXYZ.Y(j)) / 2 down = -(h.GridXYZ.Y(j) - h.GridXYZ.Y(j-1)) / 2 } x, y := trX(h.GridXYZ.X(i)+left), trY(h.GridXYZ.Y(j)+down) dx, dy := trX(h.GridXYZ.X(i)+right), trY(h.GridXYZ.Y(j)+up) if !c.Contains(draw.Point{x, y}) || !c.Contains(draw.Point{dx, dy}) { continue } pa.Move(x, y) pa.Line(dx, y) pa.Line(dx, dy) pa.Line(x, dy) pa.Close() var col color.Color switch { case v < h.Min: col = h.Underflow case v > h.Max: col = h.Overflow default: col = pal[int((v-h.Min)*ps+0.5)] // Apply palette scaling. } if col != nil { c.SetColor(col) c.Fill(pa) } } } }
// naivePlot implements the a naive rendering approach for contours. // It is here as a debugging mode since it simply draws line segments // generated by conrec without further computation. func (h *Contour) naivePlot(c draw.Canvas, plt *plot.Plot) { var pal []color.Color if h.Palette != nil { pal = h.Palette.Colors() } trX, trY := plt.Transforms(&c) // Sort levels prior to palette scaling since we can't depend on // sorting as a side effect from calling contourPaths. sort.Float64s(h.Levels) // ps is a palette scaling factor to scale the palette uniformly // across the given levels. This enables a discordance between the // number of colours and the number of levels. ps := float64(len(pal)-1) / (h.Levels[len(h.Levels)-1] - h.Levels[0]) if len(h.Levels) == 1 { ps = 0 } levelMap := make(map[float64]int) for i, z := range h.Levels { levelMap[z] = i } // Draw each line segment as conrec generates it. var pa vg.Path conrec(h.GridXYZ, h.Levels, func(_, _ int, l line, z float64) { if math.IsNaN(z) { return } pa = pa[:0] x1, y1 := trX(l.p1.X), trY(l.p1.Y) x2, y2 := trX(l.p2.X), trY(l.p2.Y) if !c.Contains(draw.Point{x1, y1}) || !c.Contains(draw.Point{x2, y2}) { return } pa.Move(x1, y1) pa.Line(x2, y2) pa.Close() style := h.LineStyles[levelMap[z]%len(h.LineStyles)] var col color.Color switch { case z < h.Min: col = h.Underflow case z > h.Max: col = h.Overflow case len(pal) == 0: col = style.Color default: col = pal[int((z-h.Levels[0])*ps+0.5)] // Apply palette scaling. } if col != nil && style.Width != 0 { c.SetLineStyle(style) c.SetColor(col) c.Stroke(pa) } }) }