plotter: Labels x/y-offsets are in vg.Length and it's inconvenient

[sbinet]

while working on the glyphboxes issue, I've noticed:

package plotter // import "gonum.org/v1/plot/plotter"

// Labels implements the Plotter interface,
// drawing a set of labels at specified points.
type Labels struct {
        XYs

        // Labels is the set of labels corresponding
        // to each point.
        Labels []string

        // TextStyle is the style of the label text. Each label
        // can have a different text style.
        TextStyle []text.Style

        // XOffset and YOffset are added directly to the final
        // label X and Y location respectively.
        XOffset, YOffset vg.Length
}

the {X,Y}Offset fields are in vg.Length (so, centimeters and what not).
it's convenient when drawing the labels:

// 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 {
                pt := vg.Point{X: trX(l.XYs[i].X), Y: trY(l.XYs[i].Y)}
                if !c.Contains(pt) {
                        continue
                }
                pt.X += l.XOffset
                pt.Y += l.YOffset
                c.FillText(l.TextStyle[i], pt, label)
        }
}

but rather inconvenient when trying to compute the glyphbox around each label:

// GlyphBoxes returns a slice of GlyphBoxes,
// one for each of the labels, implementing the
// plot.GlyphBoxer interface.
func (l *Labels) GlyphBoxes(p *plot.Plot) []plot.GlyphBox {
        bs := make([]plot.GlyphBox, len(l.Labels))
        for i, label := range l.Labels {
                pt := l.XYs[i]
                pt.X += l.XOffset // error (cannot add float64 and vg.Length)
                pt.Y += l.YOffset // ditto
                bs[i].X = p.X.Norm(pt.X)
                bs[i].Y = p.Y.Norm(pt.Y)
                sty := l.TextStyle[i]
                bs[i].Rectangle = sty.Rectangle(label)
        }
        return bs
}

(the original code of Labels.GlyphBoxes(...) was missing the x/y-offsets)

there's no way (at least, I couldn't find one) to go from vg units back to "canvas/user" units.
(even less so when one has only a plot.Plot in hands, w/o the corresponding draw.Canvas as one has in Labels.Plot(c,p))

I see two avenues to solve this:

• change {X,Y}Offset to data units (and document)
• modify the GlyphBoxes signature (and the according plot.GlyphBoxer interface) to take an additional draw.Canvas argument, add a way (to plot.Plot?) to go from vg.Length units back to "data units".

option a) is probably less wide-ranging a change (only a couple of plotters in gonum/plot are using these fields)

(in any event, adding a method to go from vg.Length units back to "data units" may very well be quite convenient, though. I had the use for such a thing for go-hep/hplot here when trying to set labels in "normalized" coordinates.)

thoughts?

[kortschak]

I don't think offsets should be in data units. That would be a very surprising behaviour since offsetting text on a plot is a typesetting action.

It's not entirely clear to me why you need to communicate back from typesetting lengths to data units.

Also, I think that the GlyphBoxes method should look like this,

func (l *Labels) GlyphBoxes(p *plot.Plot) []plot.GlyphBox {
	bs := make([]plot.GlyphBox, len(l.Labels))
	for i, label := range l.Labels {
		bs[i].X = p.X.Norm(l.XYs[i].X) + float64(l.XOffset)
		bs[i].Y = p.Y.Norm(l.XYs[i].Y) + float64(l.YOffset)
		sty := l.TextStyle[i]
		bs[i].Rectangle = sty.Rectangle(label)
	}
	return bs
}

with the offset added after the scaling, just as it is in the Plot method.

[sbinet]

I did have tried that.

with:

// +build ignore

package main

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

	"gonum.org/v1/plot"
	"gonum.org/v1/plot/font"
	"gonum.org/v1/plot/plotter"
	"gonum.org/v1/plot/vg"
	"gonum.org/v1/plot/vg/draw"
	"gonum.org/v1/plot/vg/vgimg"
)

func main() {
	p := plot.New()
	p.X.Min = 0
	p.X.Max = 10
	p.Y.Min = 0
	p.Y.Max = 10

	f1 := plotter.NewFunction(func(x float64) float64 { return 5 })
	f1.LineStyle.Color = color.RGBA{R: 255, A: 255}

	f2 := plotter.NewFunction(func(x float64) float64 { return 6 })
	f2.LineStyle.Color = color.RGBA{B: 255, A: 255}

	if true {
		labels, err := plotter.NewLabels(plotter.XYLabels{
			XYs: []plotter.XY{
				{X: 2.5, Y: 2.5},
				{X: 7.5, Y: 2.5},
				{X: 7.5, Y: 7.5},
				{X: 2.5, Y: 7.5},
			},
			Labels: []string{"Agg", "Bgg", "Cgg", "x"},
		})
		if err != nil {
			log.Fatalf("could not creates labels plotter: %+v", err)
		}
		for i := range labels.TextStyle {
			sty := &labels.TextStyle[i]
			sty.Font = font.From(sty.Font, 20)
		}
		p.Add(labels)
	}

	{
		labels, err := plotter.NewLabels(plotter.XYLabels{
			XYs: []plotter.XY{
				{X: 2.5, Y: 2.5},
				{X: 7.5, Y: 2.5},
				{X: 7.5, Y: 7.5},
				{X: 2.5, Y: 7.5},
			},
			Labels: []string{"App", "Bpp", "Cpp", "Dpp"},
		})
		if err != nil {
			log.Fatalf("could not creates labels plotter: %+v", err)
		}
		for i := range labels.TextStyle {
			sty := &labels.TextStyle[i]
			sty.Font = font.From(sty.Font, 20)
		}
		labels.XOffset = 50
		p.Add(labels)
	}

	p.Add(plotter.NewGlyphBoxes())
	p.Add(f1, f2)
	p.Add(plotter.NewGrid())

	p.Legend.Add("f1", f1)
	p.Legend.Add("f2", f2)
	p.Legend.Top = true

	c := vgimg.PngCanvas{
		Canvas: vgimg.New(20*vg.Centimeter, 15*vg.Centimeter),
	}

	d := draw.New(c)
	p.Draw(d)
	p.DrawGlyphBoxes(d)

	f, err := os.Create("box.png")
	if err != nil {
		log.Fatalf("error: %+v", err)
	}
	defer f.Close()

	_, err = c.WriteTo(f)
	if err != nil {
		log.Fatalf("error: %+v", err)
	}

	err = f.Close()
	if err != nil {
		log.Fatalf("error: %+v", err)
	}
}

I get:

(i.e.: the boxes around the shifted text labels are off screen and one can only see the boxes around the non-shifted labels)

[kortschak]

That doesn't build for me using the current master.

[sbinet]

right, I was running on top of my changes from #708.

here is the diff for running on top of HEAD:

87c87
< 	p.DrawGlyphBoxes(d)
---
> 	p.DrawGlyphBoxes(&d)

sorry about that.

[kortschak]

This fixes the issue, though it's ugly.

func (l *Labels) GlyphBoxes(p *plot.Plot) []plot.GlyphBox {
	bs := make([]plot.GlyphBox, len(l.Labels))
	offset := vg.Point{X: l.XOffset, Y: l.YOffset}
	for i, label := range l.Labels {
		rect := l.TextStyle[i].Rectangle(label)
		rect.Min = rect.Min.Add(offset)
		rect.Max = rect.Max.Add(offset)
		bs[i] = plot.GlyphBox{
			X:         p.X.Norm(l.XYs[i].X),
			Y:         p.Y.Norm(l.XYs[i].Y),
			Rectangle: rect,
		}
	}
	return bs
}

Obviously, the sty.Rectangle method needs to understand the offset, but this will do.

[sbinet]

that worked. thanks :)