plot: consider implementing a rotated/transformed canvas

[sbinet]

this has come up on slack. it would be great to be able to implement this kind of plot:

• https://matplotlib.org/stable/gallery/axes_grid1/scatter_hist_locatable_axes.html#sphx-glr-gallery-axes-grid1-scatter-hist-locatable-axes-py

to achieve this sort of thing, we need to be able to rotate a plot to tack it on the right hand side of the bottom left plot.

the following program is an attempt at reproducing the same plot (sans the rotated canvas).

package main

import (
	"flag"
	"image/color"
	"log"
	"math/rand"
	"os"

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

func main() {
	var ratio = flag.Bool("ratio", false, "apply a 1/3 ratio")
	flag.Parse()

	const (
		rows = 2
		cols = 2
	)

	var blue = color.RGBA{R: 24, G: 90, B: 169, A: 255}

	ps := make([][]*plot.Plot, rows)
	for i := range ps {
		ps[i] = make([]*plot.Plot, cols)
		for j := range ps[i] {
			if i == 0 && j == 1 {
				continue
			}
			ps[i][j] = plot.New()
		}
	}

	const N = 1000
	rnd := rand.New(rand.NewSource(1))
	data := make(plotter.XYs, N)
	xs := make(plotter.Values, N)
	ys := make(plotter.Values, N)
	for i := range data {
		xs[i] = rnd.NormFloat64() * 2
		ys[i] = rnd.NormFloat64()
		data[i].X = xs[i]
		data[i].Y = ys[i]
	}

	s, err := plotter.NewScatter(data)
	if err != nil {
		log.Panic(err)
	}
	s.GlyphStyle.Color = blue
	s.GlyphStyle.Radius = vg.Points(3)

	ps[1][0].Add(s)

	// histo-x
	hx, err := plotter.NewHist(xs, 20)
	if err != nil {
		log.Panic(err)
	}
	hx.FillColor = blue
	hx.LineStyle.Color = blue

	ps[0][0].Add(hx)

	// histo-y
	hy, err := plotter.NewHist(ys, 20)
	if err != nil {
		log.Panic(err)
	}
	hy.FillColor = blue
	hy.LineStyle.Color = blue

	ps[1][1].Add(hy)

	const (
		xsize = 30 * vg.Centimeter
		ysize = 30 * vg.Centimeter
	)
	img := vgimg.New(xsize, ysize)
	dc := draw.New(img)

	const padding = 0.2 * vg.Centimeter
	t := draw.Tiles{
		Rows:      rows,
		Cols:      cols,
		PadTop:    padding,
		PadBottom: padding,
		PadRight:  padding,
		PadLeft:   padding,
		PadX:      padding,
		PadY:      padding,
	}

	cs := plot.Align(ps, t, dc)

	// aspect ratio.
	if *ratio {
		var (
			top = &cs[0][0]
			mid = &cs[1][0]
			rhs = &cs[1][1]
		)
		top.Rectangle.Min.Y += 0.6 * top.Rectangle.Size().Y
		top.Rectangle.Max.X += 0.6 * top.Rectangle.Size().X

		mid.Rectangle.Max.Y += 0.6 * mid.Rectangle.Size().Y
		mid.Rectangle.Max.X += 0.6 * mid.Rectangle.Size().X

		rhs.Rectangle.Max.Y += 0.6 * rhs.Rectangle.Size().Y
		rhs.Rectangle.Min.X += 0.6 * rhs.Rectangle.Size().X
	}

	ps[0][0].X.Tick.Marker = NoTicks{}
	ps[1][1].Y.Tick.Marker = NoTicks{}

	for j := 0; j < rows; j++ {
		for i := 0; i < cols; i++ {
			if ps[j][i] == nil {
				continue
			}
			ps[j][i].Draw(cs[j][i])
		}
	}

	w, err := os.Create("rotated-canvas.png")
	if err != nil {
		panic(err)
	}
	defer w.Close()

	png := vgimg.PngCanvas{Canvas: img}
	if _, err := png.WriteTo(w); err != nil {
		panic(err)
	}
}

// NoTicks implements plot.Ticker but does not display any tick.
type NoTicks struct{}

// Ticks returns Ticks in a specified range
func (NoTicks) Ticks(min, max float64) []plot.Tick {
	return nil
}