func (b horizQuartPlot) Plot(c draw.Canvas, plt *plot.Plot) {
trX, trY := plt.Transforms(&c)
y := trY(b.Location)
if !c.ContainsY(y) {
return
}
y += b.Offset
med := draw.Point{X: trX(b.Median), Y: y}
q1 := trX(b.Quartile1)
q3 := trX(b.Quartile3)
aLow := trX(b.AdjLow)
aHigh := trX(b.AdjHigh)
c.StrokeLine2(b.WhiskerStyle, aHigh, y, q3, y)
if c.ContainsX(med.X) {
c.DrawGlyphNoClip(b.MedianStyle, med)
}
c.StrokeLine2(b.WhiskerStyle, aLow, y, q1, y)
ostyle := b.MedianStyle
ostyle.Radius = b.MedianStyle.Radius / 2
for _, out := range b.Outside {
x := trX(b.Value(out))
if c.ContainsX(x) {
c.DrawGlyphNoClip(ostyle, draw.Point{X: x, Y: y})
}
}
}
// Plot draws the QuartPlot on Canvas c and Plot plt.
func (b *QuartPlot) Plot(c draw.Canvas, plt *plot.Plot) {
if b.Horizontal {
b := &horizQuartPlot{b}
b.Plot(c, plt)
return
}
trX, trY := plt.Transforms(&c)
x := trX(b.Location)
if !c.ContainsX(x) {
return
}
x += b.Offset
med := draw.Point{X: x, Y: 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: x, Y: y})
}
}
}
// AddBoxPlots adds box plot plotters to a plot and
// sets the X axis of the plot to be nominal.
// The variadic arguments must be either strings
// or plotter.Valuers. Each valuer adds a box plot
// to the plot at the X location corresponding to
// the number of box plots added before it. If a
// plotter.Valuer is immediately preceeded by a
// string then the string value is used to label the
// tick mark for the box plot's X location.
//
// If an error occurs then none of the plotters are added
// to the plot, and the error is returned.
func AddBoxPlots(plt *plot.Plot, width vg.Length, vs ...interface{}) error {
var ps []plot.Plotter
var names []string
name := ""
for _, v := range vs {
switch t := v.(type) {
case string:
name = t
case plotter.Valuer:
b, err := plotter.NewBoxPlot(width, float64(len(names)), t)
if err != nil {
return err
}
ps = append(ps, b)
names = append(names, name)
name = ""
default:
panic(fmt.Sprintf("AddBoxPlots handles strings and plotter.Valuers, got %T", t))
}
}
plt.Add(ps...)
plt.NominalX(names...)
return nil
}
// AddLines adds Line plotters to a plot.
// The variadic arguments must be either strings
// or plotter.XYers. Each plotter.XYer is added to
// the plot using the next color and dashes
// shape via the Color and Dashes functions.
// If a plotter.XYer is immediately preceeded by
// a string then a legend entry is added to the plot
// using the string as the name.
//
// If an error occurs then none of the plotters are added
// to the plot, and the error is returned.
func AddLines(plt *plot.Plot, vs ...interface{}) error {
var ps []plot.Plotter
names := make(map[*plotter.Line]string)
name := ""
var i int
for _, v := range vs {
switch t := v.(type) {
case string:
name = t
case plotter.XYer:
l, err := plotter.NewLine(t)
if err != nil {
return err
}
l.Color = Color(i)
l.Dashes = Dashes(i)
i++
ps = append(ps, l)
if name != "" {
names[l] = name
name = ""
}
default:
panic(fmt.Sprintf("AddLines handles strings and plotter.XYers, got %T", t))
}
}
plt.Add(ps...)
for p, n := range names {
plt.Legend.Add(n, p)
}
return nil
}
// 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)
}
}
// AddScatters adds Scatter plotters to a plot.
// The variadic arguments must be either strings
// or plotter.XYers. Each plotter.XYer is added to
// the plot using the next color, and glyph shape
// via the Color and Shape functions. If a
// plotter.XYer is immediately preceeded by
// a string then a legend entry is added to the plot
// using the string as the name.
//
// If an error occurs then none of the plotters are added
// to the plot, and the error is returned.
func AddScatters(plt *plot.Plot, vs ...interface{}) error {
var ps []plot.Plotter
names := make(map[*plotter.Scatter]string)
name := ""
var i int
for _, v := range vs {
switch t := v.(type) {
case string:
name = t
case plotter.XYer:
s, err := plotter.NewScatter(t)
if err != nil {
return err
}
s.Color = Color(i)
s.Shape = Shape(i)
i++
ps = append(ps, s)
if name != "" {
names[s] = name
name = ""
}
default:
panic(fmt.Sprintf("AddScatters handles strings and plotter.XYers, got %T", t))
}
}
plt.Add(ps...)
for p, n := range names {
plt.Legend.Add(n, p)
}
return nil
}
// 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.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...)
}
}
// 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 (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)
}
}
// 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: x, Y: y}) {
continue
}
x += l.XOffset
y += l.YOffset
c.FillText(l.TextStyle, x, y, l.XAlign, l.YAlign, label)
}
}
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 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 draws the BoxPlot on Canvas c and Plot plt.
func (b *BoxPlot) Plot(c draw.Canvas, plt *plot.Plot) {
if b.Horizontal {
b := &horizBoxPlot{b}
b.Plot(c, plt)
return
}
trX, trY := plt.Transforms(&c)
x := trX(b.Location)
if !c.ContainsX(x) {
return
}
x += b.Offset
med := trY(b.Median)
q1 := trY(b.Quartile1)
q3 := trY(b.Quartile3)
aLow := trY(b.AdjLow)
aHigh := trY(b.AdjHigh)
box := c.ClipLinesY([]draw.Point{
{x - b.Width/2, q1},
{x - b.Width/2, q3},
{x + b.Width/2, q3},
{x + b.Width/2, q1},
{x - b.Width/2 - b.BoxStyle.Width/2, q1},
})
c.StrokeLines(b.BoxStyle, box...)
medLine := c.ClipLinesY([]draw.Point{
{x - b.Width/2, med},
{x + b.Width/2, med},
})
c.StrokeLines(b.MedianStyle, medLine...)
cap := b.CapWidth / 2
whisks := c.ClipLinesY([]draw.Point{{x, q3}, {x, aHigh}},
[]draw.Point{{x - cap, aHigh}, {x + cap, aHigh}},
[]draw.Point{{x, q1}, {x, aLow}},
[]draw.Point{{x - cap, aLow}, {x + cap, aLow}})
c.StrokeLines(b.WhiskerStyle, whisks...)
for _, out := range b.Outside {
y := trY(b.Value(out))
if c.ContainsY(y) {
c.DrawGlyphNoClip(b.GlyphStyle, draw.Point{X: x, Y: y})
}
}
}
// AddYErrorBars adds YErrorBars to a plot.
// The variadic arguments must be
// of type plotter.XYer, and plotter.YErrorer.
// Each errorer is added to the plot the color from
// the Colors function corresponding to its position
// in the argument list.
//
// If an error occurs then none of the plotters are added
// to the plot, and the error is returned.
func AddYErrorBars(plt *plot.Plot, es ...interface {
plotter.XYer
plotter.YErrorer
}) error {
var ps []plot.Plotter
for i, e := range es {
bars, err := plotter.NewYErrorBars(e)
if err != nil {
return err
}
bars.Color = Color(i)
ps = append(ps, bars)
}
plt.Add(ps...)
return nil
}
// 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)...)
}
}
// AddStackedAreaPlots adds stacked area plot plotters to a plot.
// The variadic arguments must be either strings
// or plotter.Valuers. Each valuer adds a stacked area
// plot to the plot below the stacked area plots added
// before it. If a plotter.Valuer is immediately
// preceeded by a string then the string value is used to
// label the legend.
// Plots should be added in order of tallest to shortest,
// because they will be drawn in the order they are added
// (i.e. later plots will be painted over earlier plots).
//
// If an error occurs then none of the plotters are added
// to the plot, and the error is returned.
func AddStackedAreaPlots(plt *plot.Plot, xs plotter.Valuer, vs ...interface{}) error {
var ps []plot.Plotter
names := make(map[*plotter.Line]string)
name := ""
var i int
for _, v := range vs {
switch t := v.(type) {
case string:
name = t
case plotter.Valuer:
if xs.Len() != t.Len() {
return errors.New("X/Y length mismatch")
}
// Make a line plotter and set its style.
l, err := plotter.NewLine(combineXYs{xs: xs, ys: t})
if err != nil {
return err
}
l.LineStyle.Width = vg.Points(0)
color := Color(i)
i++
l.ShadeColor = &color
ps = append(ps, l)
if name != "" {
names[l] = name
name = ""
}
default:
panic(fmt.Sprintf("AddStackedAreaPlots handles strings and plotter.Valuers, got %T", t))
}
}
plt.Add(ps...)
for p, n := range names {
plt.Legend.Add(n, p)
}
return nil
}
func (b horizBoxPlot) Plot(c draw.Canvas, plt *plot.Plot) {
trX, trY := plt.Transforms(&c)
y := trY(b.Location)
if !c.ContainsY(y) {
return
}
y += b.Offset
med := trX(b.Median)
q1 := trX(b.Quartile1)
q3 := trX(b.Quartile3)
aLow := trX(b.AdjLow)
aHigh := trX(b.AdjHigh)
box := c.ClipLinesX([]draw.Point{
{q1, y - b.Width/2},
{q3, y - b.Width/2},
{q3, y + b.Width/2},
{q1, y + b.Width/2},
{q1, y - b.Width/2 - b.BoxStyle.Width/2},
})
c.StrokeLines(b.BoxStyle, box...)
medLine := c.ClipLinesX([]draw.Point{
{med, y - b.Width/2},
{med, y + b.Width/2},
})
c.StrokeLines(b.MedianStyle, medLine...)
cap := b.CapWidth / 2
whisks := c.ClipLinesX([]draw.Point{{q3, y}, {aHigh, y}},
[]draw.Point{{aHigh, y - cap}, {aHigh, y + cap}},
[]draw.Point{{q1, y}, {aLow, y}},
[]draw.Point{{aLow, y - cap}, {aLow, y + cap}})
c.StrokeLines(b.WhiskerStyle, whisks...)
for _, out := range b.Outside {
x := trX(b.Value(out))
if c.ContainsX(x) {
c.DrawGlyphNoClip(b.GlyphStyle, draw.Point{X: x, Y: y})
}
}
}
// AddErrorBars adds XErrorBars and YErrorBars
// to a plot. The variadic arguments must be
// of type plotter.XYer, and must be either a
// plotter.XErrorer, plotter.YErrorer, or both.
// Each errorer is added to the plot the color from
// the Colors function corresponding to its position
// in the argument list.
//
// If an error occurs then none of the plotters are added
// to the plot, and the error is returned.
func AddErrorBars(plt *plot.Plot, vs ...interface{}) error {
var ps []plot.Plotter
for i, v := range vs {
added := false
if xerr, ok := v.(interface {
plotter.XYer
plotter.XErrorer
}); ok {
e, err := plotter.NewXErrorBars(xerr)
if err != nil {
return err
}
e.Color = Color(i)
ps = append(ps, e)
added = true
}
if yerr, ok := v.(interface {
plotter.XYer
plotter.YErrorer
}); ok {
e, err := plotter.NewYErrorBars(yerr)
if err != nil {
return err
}
e.Color = Color(i)
ps = append(ps, e)
added = true
}
if added {
continue
}
panic(fmt.Sprintf("AddErrorBars expects plotter.XErrorer or plotter.YErrorer, got %T", v))
}
plt.Add(ps...)
return nil
}
func (b *BoxPlotWithConfidenceIntervals) Plot(c draw.Canvas, plt *plot.Plot) {
if b.Horizontal {
panic("not handling horizontal BoxPlotWithConfidenceIntervals")
}
b.BoxPlot.Plot(c, plt)
trX, trY := plt.Transforms(&c)
x := trX(b.Location)
if !c.ContainsX(x) {
return
}
x += b.Offset
mean, err, _ := meanAndConf95(b.Values)
meanLength := trY(mean)
lowLength := trY(mean - err)
highLength := trY(mean + err)
confidenceVertices := []draw.Point{
{x - b.Width/4, lowLength},
{x + b.Width/4, lowLength},
{x + b.Width/4, highLength},
{x - b.Width/4, highLength},
}
confidencePoly := c.ClipPolygonY(confidenceVertices)
gray := color.RGBA{200, 200, 200, 255}
c.FillPolygon(gray, confidencePoly)
meanLine := c.ClipLinesY([]draw.Point{
{x - b.Width/4, meanLength},
{x + b.Width/4, meanLength},
})
meanStyle := b.BoxStyle
meanStyle.Color = color.RGBA{150, 150, 150, 255}
c.StrokeLines(meanStyle, meanLine...)
}
// 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)...)
}
// AddLinePoints adds Line and Scatter plotters to a
// plot. The variadic arguments must be either strings
// or plotter.XYers. Each plotter.XYer is added to
// the plot using the next color, dashes, and glyph
// shape via the Color, Dashes, and Shape functions.
// If a plotter.XYer is immediately preceeded by
// a string then a legend entry is added to the plot
// using the string as the name.
//
// If an error occurs then none of the plotters are added
// to the plot, and the error is returned.
func AddLinePoints(plt *plot.Plot, vs ...interface{}) error {
var ps []plot.Plotter
names := make(map[[2]plot.Thumbnailer]string)
name := ""
var i int
for _, v := range vs {
switch t := v.(type) {
case string:
name = t
case plotter.XYer:
l, s, err := plotter.NewLinePoints(t)
if err != nil {
return err
}
l.Color = Color(i)
l.Dashes = Dashes(i)
s.Color = Color(i)
s.Shape = Shape(i)
i++
ps = append(ps, l, s)
if name != "" {
names[[2]plot.Thumbnailer{l, s}] = name
name = ""
}
default:
panic(fmt.Sprintf("AddLinePoints handles strings and plotter.XYers, got %T", t))
}
}
plt.Add(ps...)
for ps, n := range names {
plt.Legend.Add(n, ps[0], ps[1])
}
return nil
}
// 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)
}
})
}
// 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)})
}
}