// Plot implements the plot.Plotter interface. func (b *BarChart) Plot(c draw.Canvas, plt *plot.Plot) { trX, trY := plt.Transforms(&c) for i, ht := range b.Values { x := b.XMin + float64(i) xmin := trX(float64(x)) if !c.ContainsX(xmin) { continue } xmin = xmin - b.Width/2 + b.Offset xmax := xmin + b.Width bottom := b.stackedOn.BarHeight(i) ymin := trY(bottom) ymax := trY(bottom + ht) pts := []draw.Point{ {xmin, ymin}, {xmin, ymax}, {xmax, ymax}, {xmax, ymin}, } poly := c.ClipPolygonY(pts) c.FillPolygon(b.Color, poly) pts = append(pts, draw.Point{xmin, ymin}) outline := c.ClipLinesY(pts) c.StrokeLines(b.LineStyle, outline...) } }
// Plot implements the Plotter interface, drawing a line // that connects each point in the Line. func (f *Function) Plot(c draw.Canvas, p *plot.Plot) { trX, trY := p.Transforms(&c) d := (p.X.Max - p.X.Min) / float64(f.Samples-1) line := make([]draw.Point, f.Samples) for i := range line { x := p.X.Min + float64(i)*d line[i].X = trX(x) line[i].Y = trY(f.F(x)) } // For every continuous block of non-NaN Y values, stroke lines for i := 0; i < len(line); i++ { if !math.IsNaN(float64(line[i].Y)) { j := i + 1 for ; j < len(line); j++ { if math.IsNaN(float64(line[j].Y)) { break } } c.StrokeLines(f.LineStyle, c.ClipLinesXY(line[i:j])...) i = j } } }
// Plot draws the Line, implementing the plot.Plotter interface. func (rp *ResponsePlotter) Plot(canvas vgdraw.Canvas, plt *plot.Plot) { trX, trY := plt.Transforms(&canvas) start := float64(rp.Response.GetStartTime()) step := float64(rp.Response.GetStepTime()) absent := rp.Response.IsAbsent lines := make([][]vgdraw.Point, 1) lines[0] = make([]vgdraw.Point, 0, len(rp.Response.Values)) /* ikruglov * swithing between lineMode and looping inside * is more branch-prediction friendly i.e. potentially faster */ switch rp.lineMode { case "slope": currentLine := 0 lastAbsent := false for i, v := range rp.Response.Values { if absent[i] { lastAbsent = true } else if lastAbsent { currentLine++ lines = append(lines, make([]vgdraw.Point, 1)) lines[currentLine][0] = vgdraw.Point{X: trX(start + float64(i)*step), Y: trY(v)} lastAbsent = false } else { lines[currentLine] = append(lines[currentLine], vgdraw.Point{X: trX(start + float64(i)*step), Y: trY(v)}) } } case "connected": for i, v := range rp.Response.Values { if absent[i] { continue } lines[0] = append(lines[0], vgdraw.Point{X: trX(start + float64(i)*step), Y: trY(v)}) } case "drawAsInfinite": for i, v := range rp.Response.Values { if !absent[i] && v > 0 { infiniteLine := []vgdraw.Point{ vgdraw.Point{X: trX(start + float64(i)*step), Y: canvas.Y(1)}, vgdraw.Point{X: trX(start + float64(i)*step), Y: canvas.Y(0)}, } lines = append(lines, infiniteLine) } } //case "staircase": // TODO default: panic("Unimplemented " + rp.lineMode) } canvas.StrokeLines(rp.LineStyle, lines...) }
// DataCanvas returns a new draw.Canvas that // is the subset of the given draw area into which // the plot data will be drawn. func (p *Plot) DataCanvas(da draw.Canvas) draw.Canvas { if p.Title.Text != "" { da.Max.Y -= p.Title.Height(p.Title.Text) - p.Title.Font.Extents().Descent da.Max.Y -= p.Title.Padding } p.X.sanitizeRange() x := horizontalAxis{p.X} p.Y.sanitizeRange() y := verticalAxis{p.Y} return padY(p, padX(p, da.Crop(y.size(), x.size(), 0, 0))) }
// Plot implements the Plotter interface, drawing a line // that connects each point in the Line. func (f *Function) Plot(c draw.Canvas, p *plot.Plot) { trX, trY := p.Transforms(&c) d := (p.X.Max - p.X.Min) / float64(f.Samples-1) line := make([]draw.Point, f.Samples) for i := range line { x := p.X.Min + float64(i)*d line[i].X = trX(x) line[i].Y = trY(f.F(x)) } c.StrokeLines(f.LineStyle, c.ClipLinesXY(line)...) }
// Plot implements the Plotter interface, drawing labels. func (l *Labels) Plot(c draw.Canvas, p *plot.Plot) { trX, trY := p.Transforms(&c) for i, label := range l.Labels { x := trX(l.XYs[i].X) y := trY(l.XYs[i].Y) if !c.Contains(draw.Point{x, y}) { continue } x += l.XOffset y += l.YOffset c.FillText(l.TextStyle, x, y, l.XAlign, l.YAlign, label) } }
// Plot implements the Plotter interface, drawing labels. func (e *YErrorBars) Plot(c draw.Canvas, p *plot.Plot) { trX, trY := p.Transforms(&c) for i, err := range e.YErrors { x := trX(e.XYs[i].X) ylow := trY(e.XYs[i].Y - math.Abs(err.Low)) yhigh := trY(e.XYs[i].Y + math.Abs(err.High)) bar := c.ClipLinesY([]draw.Point{{x, ylow}, {x, yhigh}}) c.StrokeLines(e.LineStyle, bar...) e.drawCap(&c, x, ylow) e.drawCap(&c, x, yhigh) } }
// Plot implements the Plotter interface, drawing labels. func (e *XErrorBars) Plot(c draw.Canvas, p *plot.Plot) { trX, trY := p.Transforms(&c) for i, err := range e.XErrors { y := trY(e.XYs[i].Y) xlow := trX(e.XYs[i].X - math.Abs(err.Low)) xhigh := trX(e.XYs[i].X + math.Abs(err.High)) bar := c.ClipLinesX([]draw.Point{{xlow, y}, {xhigh, y}}) c.StrokeLines(e.LineStyle, bar...) e.drawCap(&c, xlow, y) e.drawCap(&c, xhigh, y) } }
// bottomMost returns the bottom-most GlyphBox. func bottomMost(c *draw.Canvas, boxes []GlyphBox) GlyphBox { miny := c.Min.Y l := GlyphBox{} for _, b := range boxes { if b.Size().Y <= 0 { continue } if y := c.Y(b.Y) + b.Min.Y; y < miny && b.Y >= 0 { miny = y l = b } } return l }
// topMost returns the top-most GlyphBox. func topMost(c *draw.Canvas, boxes []GlyphBox) GlyphBox { maxy := c.Max.Y t := GlyphBox{Y: 1} for _, b := range boxes { if b.Size().Y <= 0 { continue } if y := c.Y(b.Y) + b.Min.Y + b.Size().Y; y > maxy && b.Y <= 1 { maxy = y t = b } } return t }
// leftMost returns the left-most GlyphBox. func leftMost(c *draw.Canvas, boxes []GlyphBox) GlyphBox { minx := c.Min.X l := GlyphBox{} for _, b := range boxes { if b.Size().X <= 0 { continue } if x := c.X(b.X) + b.Min.X; x < minx && b.X >= 0 { minx = x l = b } } return l }
// rightMost returns the right-most GlyphBox. func rightMost(c *draw.Canvas, boxes []GlyphBox) GlyphBox { maxx := c.Max.X r := GlyphBox{X: 1} for _, b := range boxes { if b.Size().X <= 0 { continue } if x := c.X(b.X) + b.Min.X + b.Size().X; x > maxx && b.X <= 1 { maxx = x r = b } } return r }
// 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)) }
// Plot implements the plot.Plotter interface. func (g *Grid) Plot(c draw.Canvas, plt *plot.Plot) { trX, trY := plt.Transforms(&c) if g.Vertical.Color == nil { goto horiz } for _, tk := range plt.X.Tick.Marker.Ticks(plt.X.Min, plt.X.Max) { if tk.IsMinor() { continue } x := trX(tk.Value) c.StrokeLine2(g.Vertical, x, c.Min.Y, x, c.Min.Y+c.Size().Y) } horiz: if g.Horizontal.Color == nil { return } for _, tk := range plt.Y.Tick.Marker.Ticks(plt.Y.Min, plt.Y.Max) { if tk.IsMinor() { continue } y := trY(tk.Value) c.StrokeLine2(g.Horizontal, c.Min.X, y, c.Min.X+c.Size().X, y) } }
// 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()) } }
func (b *BarChart) Thumbnail(c *draw.Canvas) { pts := []draw.Point{ {c.Min.X, c.Min.Y}, {c.Min.X, c.Max.Y}, {c.Max.X, c.Max.Y}, {c.Max.X, c.Min.Y}, } poly := c.ClipPolygonY(pts) c.FillPolygon(b.Color, poly) pts = append(pts, draw.Point{c.Min.X, c.Min.Y}) outline := c.ClipLinesY(pts) c.StrokeLines(b.LineStyle, outline...) }
// 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) } } } }
// draw draws the legend to the given draw.Canvas. func (l *Legend) draw(c draw.Canvas) { iconx := c.Min.X textx := iconx + l.ThumbnailWidth + l.TextStyle.Width(" ") xalign := 0.0 if !l.Left { iconx = c.Max.X - l.ThumbnailWidth textx = iconx - l.TextStyle.Width(" ") xalign = -1 } textx += l.XOffs iconx += l.XOffs enth := l.entryHeight() y := c.Max.Y - enth if !l.Top { y = c.Min.Y + (enth+l.Padding)*(vg.Length(len(l.entries))-1) } y += l.YOffs icon := &draw.Canvas{ Canvas: c.Canvas, Rectangle: draw.Rectangle{ Min: draw.Point{iconx, y}, Max: draw.Point{iconx + l.ThumbnailWidth, y + enth}, }, } for _, e := range l.entries { for _, t := range e.thumbs { t.Thumbnail(icon) } yoffs := (enth - l.TextStyle.Height(e.text)) / 2 c.FillText(l.TextStyle, textx, icon.Min.Y+yoffs, xalign, 0, e.text) icon.Min.Y -= enth + l.Padding icon.Max.Y -= enth + l.Padding } }
// Plot implements the Plotter interface, drawing a line // that connects each point in the Line. func (h *Histogram) Plot(c draw.Canvas, p *plot.Plot) { trX, trY := p.Transforms(&c) for _, bin := range h.Bins { pts := []draw.Point{ {trX(bin.Min), trY(0)}, {trX(bin.Max), trY(0)}, {trX(bin.Max), trY(bin.Weight)}, {trX(bin.Min), trY(bin.Weight)}, } if h.FillColor != nil { c.FillPolygon(h.FillColor, c.ClipPolygonXY(pts)) } pts = append(pts, draw.Point{trX(bin.Min), trY(0)}) c.StrokeLines(h.LineStyle, c.ClipLinesXY(pts)...) } }
// Thumbnail the thumbnail for the Line, // implementing the plot.Thumbnailer interface. func (pts *Line) Thumbnail(c *draw.Canvas) { if pts.ShadeColor != nil { points := []draw.Point{ {c.Min.X, c.Min.Y}, {c.Min.X, c.Max.Y}, {c.Max.X, c.Max.Y}, {c.Max.X, c.Min.Y}, } poly := c.ClipPolygonY(points) c.FillPolygon(*pts.ShadeColor, poly) points = append(points, draw.Point{c.Min.X, c.Min.Y}) } else { y := c.Center().Y c.StrokeLine2(pts.LineStyle, c.Min.X, y, c.Max.X, y) } }
// Thumbnail draws a rectangle in the given style of the histogram. func (h *Histogram) Thumbnail(c *draw.Canvas) { ymin := c.Min.Y ymax := c.Max.Y xmin := c.Min.X xmax := c.Max.X pts := []draw.Point{ {xmin, ymin}, {xmax, ymin}, {xmax, ymax}, {xmin, ymax}, } if h.FillColor != nil { c.FillPolygon(h.FillColor, c.ClipPolygonXY(pts)) } pts = append(pts, draw.Point{xmin, ymin}) c.StrokeLines(h.LineStyle, c.ClipLinesXY(pts)...) }
func (g GlyphBoxes) Plot(c draw.Canvas, plt *plot.Plot) { for _, b := range plt.GlyphBoxes(plt) { x := c.X(b.X) + b.Rectangle.Min.X y := c.Y(b.Y) + b.Rectangle.Min.Y c.StrokeLines(g.LineStyle, []draw.Point{ {x, y}, {x + b.Rectangle.Size().X, y}, {x + b.Rectangle.Size().X, y + b.Rectangle.Size().Y}, {x, y + b.Rectangle.Size().Y}, {x, y}, }) } }
// 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)...) }
func (b *QuartPlot) Plot(c draw.Canvas, plt *plot.Plot) { trX, trY := plt.Transforms(&c) x := trX(b.Location) if !c.ContainsX(x) { return } x += b.Offset med := draw.Point{x, trY(b.Median)} q1 := trY(b.Quartile1) q3 := trY(b.Quartile3) aLow := trY(b.AdjLow) aHigh := trY(b.AdjHigh) c.StrokeLine2(b.WhiskerStyle, x, aHigh, x, q3) if c.ContainsY(med.Y) { c.DrawGlyphNoClip(b.MedianStyle, med) } c.StrokeLine2(b.WhiskerStyle, x, aLow, x, q1) ostyle := b.MedianStyle ostyle.Radius = b.MedianStyle.Radius / 2 for _, out := range b.Outside { y := trY(b.Value(out)) if c.ContainsY(y) { c.DrawGlyphNoClip(ostyle, draw.Point{x, y}) } } }
// Plot implements the plot.Plotter interface. func (b *BarChart) Plot(c draw.Canvas, plt *plot.Plot) { trCat, trVal := plt.Transforms(&c) if b.Horizontal { trCat, trVal = trVal, trCat } for i, ht := range b.Values { catVal := b.XMin + float64(i) catMin := trCat(float64(catVal)) if !b.Horizontal { if !c.ContainsX(catMin) { continue } } else { if !c.ContainsY(catMin) { continue } } catMin = catMin - b.Width/2 + b.Offset catMax := catMin + b.Width bottom := b.stackedOn.BarHeight(i) valMin := trVal(bottom) valMax := trVal(bottom + ht) var pts []draw.Point var poly []draw.Point if !b.Horizontal { pts = []draw.Point{ {catMin, valMin}, {catMin, valMax}, {catMax, valMax}, {catMax, valMin}, } poly = c.ClipPolygonY(pts) } else { pts = []draw.Point{ {valMin, catMin}, {valMin, catMax}, {valMax, catMax}, {valMax, catMin}, } poly = c.ClipPolygonX(pts) } c.FillPolygon(b.Color, poly) var outline [][]draw.Point if !b.Horizontal { pts = append(pts, draw.Point{X: catMin, Y: valMin}) outline = c.ClipLinesY(pts) } else { pts = append(pts, draw.Point{X: valMin, Y: catMin}) outline = c.ClipLinesX(pts) } c.StrokeLines(b.LineStyle, outline...) } }
// 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) } }) }
// draw draws the axis along the left side of a draw.Canvas. func (a *verticalAxis) draw(c draw.Canvas) { x := c.Min.X if a.Label.Text != "" { x += a.Label.Height(a.Label.Text) c.Push() c.Rotate(math.Pi / 2) c.FillText(a.Label.TextStyle, c.Center().Y, -x, -0.5, 0, a.Label.Text) c.Pop() x += -a.Label.Font.Extents().Descent } marks := a.Tick.Marker.Ticks(a.Min, a.Max) if w := tickLabelWidth(a.Tick.Label, marks); len(marks) > 0 && w > 0 { x += w } major := false for _, t := range marks { y := c.Y(a.Norm(t.Value)) if !c.ContainsY(y) || t.IsMinor() { continue } c.FillText(a.Tick.Label, x, y, -1, -0.5, t.Label) major = true } if major { x += a.Tick.Label.Width(" ") } if a.drawTicks() && len(marks) > 0 { len := a.Tick.Length for _, t := range marks { y := c.Y(a.Norm(t.Value)) if !c.ContainsY(y) { continue } start := t.lengthOffset(len) c.StrokeLine2(a.Tick.LineStyle, x+start, y, x+len, y) } x += len } c.StrokeLine2(a.LineStyle, x, c.Min.Y, x, c.Max.Y) }
// Plot draws the Scatter, implementing the plot.Plotter // interface. func (pts *Scatter) Plot(c draw.Canvas, plt *plot.Plot) { trX, trY := plt.Transforms(&c) for _, p := range pts.XYs { c.DrawGlyph(pts.GlyphStyle, draw.Point{trX(p.X), trY(p.Y)}) } }
// Thumbnail the thumbnail for the Scatter, // implementing the plot.Thumbnailer interface. func (pts *Scatter) Thumbnail(c *draw.Canvas) { c.DrawGlyph(pts.GlyphStyle, c.Center()) }
// draw draws the axis along the lower edge of a draw.Canvas. func (a *horizontalAxis) draw(c draw.Canvas) { y := c.Min.Y if a.Label.Text != "" { y -= a.Label.Font.Extents().Descent c.FillText(a.Label.TextStyle, c.Center().X, y, -0.5, 0, a.Label.Text) y += a.Label.Height(a.Label.Text) } marks := a.Tick.Marker.Ticks(a.Min, a.Max) for _, t := range marks { x := c.X(a.Norm(t.Value)) if !c.ContainsX(x) || t.IsMinor() { continue } c.FillText(a.Tick.Label, x, y, -0.5, 0, t.Label) } if len(marks) > 0 { y += tickLabelHeight(a.Tick.Label, marks) } else { y += a.Width / 2 } if len(marks) > 0 && a.drawTicks() { len := a.Tick.Length for _, t := range marks { x := c.X(a.Norm(t.Value)) if !c.ContainsX(x) { continue } start := t.lengthOffset(len) c.StrokeLine2(a.Tick.LineStyle, x, y+start, x, y+len) } y += len } c.StrokeLine2(a.LineStyle, c.Min.X, y, c.Max.X, y) }