Hacktoberfest 2026: die Issues, die Maintainer für den Oktober markiert haben – offen und einsteigerfreundlich. Hacktoberfest-Issues durchsuchen

plot: consider implementing a rotated/transformed canvas

Offen
  • Stimmt etwas nicht?
#732 0 Kommentare 0 Reaktionen 0 zugewiesene Personen Auf GitHub ansehen

Dieses Issue hat noch niemand übernommen.

Bewertung

Schwierigkeit
5/5
Geschätzter Aufwand
Über eine Woche
Anfängerfreundlichkeit
25/100
Issue-Typ
Feature
Klarheit
Muss geklärt werden
Aktivitätsstatus
Veraltet
Tech-Stack
go
Bereich
data-visualization

Rechercherichtung

Beginne damit, die Verwendung von plot.Align und draw.New(img) im Beispiel sowie die beim Rendern verwendete vgimg-Leinwand zu lesen. Kläre die vorgesehene Rotations- und Transformations-API und überprüfe anschließend das Ergebnis, indem du das verknüpfte Scatter-Hist-Layout mit dem gedrehten Plot auf der rechten Seite reproduzierst.

Vom Indexierungsmodell aus dem Issue-Text verfasst.

Beschreibung

enhancement

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

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
}

rotated-canvas

Vorherrschende Sprache
Go
Sterne
3k
Forks
202
Keine gemergten PRs in 30 T.

Entwicklungsumgebung

Erste Schritte

  1. Lesen Sie das ganze Issue und danach den Beitragsleitfaden des Projekts.
  2. Schreiben Sie ins Issue, dass Sie es übernehmen — das erspart doppelte Arbeit.
  3. Forken Sie das Repository und arbeiten Sie in einem Branch.
  4. Öffnen Sie einen Pull Request, der die Issue-Nummer nennt.

Mehr aus gonum/plot

Alle Issues in gonum/plot

Ähnliche Issues

Weitere Issues zu Go

Neue Issues direkt in Ihr Postfach

Eine kurze Übersicht über anfängerfreundliche GitHub-Issues.