package vg
import "gonum.org/v1/plot/vg"
Package vg defines an interface for drawing 2D vector graphics.
This package is designed with the hope that many different
vector graphics back-ends can conform to the interface.
Code:play
Code:play
Code:play
Example (AddFont)¶
package main
import (
"archive/tar"
"bytes"
"compress/gzip"
"fmt"
"io"
"log"
"net/http"
"golang.org/x/image/font/opentype"
"gonum.org/v1/plot"
"gonum.org/v1/plot/font"
"gonum.org/v1/plot/plotter"
"gonum.org/v1/plot/vg"
)
func main() {
// download font from debian
const url = "http://http.debian.net/debian/pool/main/f/fonts-ipafont/fonts-ipafont_00303.orig.tar.gz"
resp, err := http.Get(url)
if err != nil {
log.Fatalf("could not download IPA font file: %+v", err)
}
defer resp.Body.Close()
ttf, err := untargz("IPAfont00303/ipam.ttf", resp.Body)
if err != nil {
log.Fatalf("could not untar archive: %+v", err)
}
fontTTF, err := opentype.Parse(ttf)
if err != nil {
log.Fatal(err)
}
mincho := font.Font{Typeface: "Mincho"}
font.DefaultCache.Add([]font.Face{
{
Font: mincho,
Face: fontTTF,
},
})
if !font.DefaultCache.Has(mincho) {
log.Fatalf("no font %q!", mincho.Typeface)
}
plot.DefaultFont = mincho
plotter.DefaultFont = mincho
p := plot.New()
p.Title.Text = "Hello, 世界!"
p.X.Label.Text = "世"
p.Y.Label.Text = "界"
labels, err := plotter.NewLabels(
plotter.XYLabels{
XYs: make(plotter.XYs, 1),
Labels: []string{"こんにちは世界"},
},
)
if err != nil {
log.Fatalf("could not create labels: %+v", err)
}
p.Add(labels)
p.Add(plotter.NewGrid())
err = p.Save(10*vg.Centimeter, 10*vg.Centimeter, "mincho-font.png")
if err != nil {
log.Fatalf("could not save plot: %+v", err)
}
}
func untargz(name string, r io.Reader) ([]byte, error) {
gr, err := gzip.NewReader(r)
if err != nil {
return nil, fmt.Errorf("could not create gzip reader: %v", err)
}
defer gr.Close()
tr := tar.NewReader(gr)
for {
hdr, err := tr.Next()
if err != nil {
if err == io.EOF {
return nil, fmt.Errorf("could not find %q in tar archive", name)
}
return nil, fmt.Errorf("could not extract header from tar archive: %v", err)
}
if hdr == nil || hdr.Name != name {
continue
}
buf := new(bytes.Buffer)
_, err = io.Copy(buf, tr)
if err != nil {
return nil, fmt.Errorf("could not extract %q file from tar archive: %v", name, err)
}
return buf.Bytes(), nil
}
}
Example (InMemoryCanvas)¶
package main
import (
"image/color"
"image/png"
"log"
"math"
"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() {
p := plot.New()
p.Title.Text = "sin(x)"
p.X.Label.Text = "x"
p.Y.Label.Text = "f(x)"
p.X.Min = -2 * math.Pi
p.X.Max = +2 * math.Pi
fct := plotter.NewFunction(func(x float64) float64 {
return math.Sin(x)
})
fct.Color = color.RGBA{R: 255, A: 255}
p.Add(fct, plotter.NewGrid())
c := vgimg.New(10*vg.Centimeter, 5*vg.Centimeter)
p.Draw(draw.New(c))
// Save image.
f, err := os.Create("testdata/sine.png")
if err != nil {
log.Fatalf("could not create output image file: %+v", err)
}
defer f.Close()
err = png.Encode(f, c.Image())
if err != nil {
log.Fatalf("could not encode image to PNG: %+v", err)
}
err = f.Close()
if err != nil {
log.Fatalf("could not close output image file: %+v", err)
}
}
Example (WriterToCanvas)¶
package main
import (
"image/color"
"log"
"math"
"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() {
p := plot.New()
p.Title.Text = "cos(x)"
p.X.Label.Text = "x"
p.Y.Label.Text = "f(x)"
p.X.Min = -2 * math.Pi
p.X.Max = +2 * math.Pi
fct := plotter.NewFunction(func(x float64) float64 {
return math.Cos(x)
})
fct.Color = color.RGBA{B: 255, A: 255}
p.Add(fct, plotter.NewGrid())
c := vgimg.PngCanvas{
Canvas: vgimg.New(10*vg.Centimeter, 5*vg.Centimeter),
}
p.Draw(draw.New(c))
// Save image.
f, err := os.Create("testdata/cosine.png")
if err != nil {
log.Fatalf("could not create output image file: %+v", err)
}
defer f.Close()
_, err = c.WriteTo(f)
if err != nil {
log.Fatalf("could not encode image to PNG: %+v", err)
}
err = f.Close()
if err != nil {
log.Fatalf("could not close output image file: %+v", err)
}
}
Index ¶
- Constants
- func Initialize(c Canvas)
- type Canvas
- type CanvasSizer
- type CanvasWriterTo
- type Length
- type Path
- func (p *Path) Arc(pt Point, rad Length, s, a float64)
- func (p *Path) Close()
- func (p *Path) CubeTo(p1, p2, pt Point)
- func (p *Path) Line(pt Point)
- func (p *Path) Move(pt Point)
- func (p *Path) QuadTo(p1, pt Point)
- type PathComp
- type Point
- func (p Point) Add(q Point) Point
- func (p Point) Dot(q Point) Length
- func (p Point) Scale(s Length) Point
- func (p Point) Sub(q Point) Point
- type Rectangle
Examples ¶
Constants ¶
const ( Inch = font.Inch Centimeter = font.Centimeter Millimeter = font.Millimeter )
Common lengths.
const ( MoveComp = iota LineComp ArcComp CurveComp CloseComp )
Constants that tag the type of each path component.
Functions ¶
func Initialize ¶
func Initialize(c Canvas)
Initialize sets all of the canvas's values to their initial values.
Types ¶
type Canvas ¶
type Canvas interface { // SetLineWidth sets the width of stroked paths. // If the width is not positive then stroked lines // are not drawn. // // The initial line width is 1 point. SetLineWidth(Length) // SetLineDash sets the dash pattern for lines. // The pattern slice specifies the lengths of // alternating dashes and gaps, and the offset // specifies the distance into the dash pattern // to start the dash. // // The initial dash pattern is a solid line. SetLineDash(pattern []Length, offset Length) // SetColor sets the current drawing color. // Note that fill color and stroke color are // the same, so if you want different fill // and stroke colors then you must set a color, // draw fills, set a new color and then draw lines. // // The initial color is black. // If SetColor is called with a nil color then black is used. SetColor(color.Color) // Rotate applies a rotation transform to the context. // The parameter is specified in radians. Rotate(rad float64) // Translate applies a translational transform // to the context. Translate(pt Point) // Scale applies a scaling transform to the // context. Scale(x, y float64) // Push saves the current line width, the // current dash pattern, the current // transforms, and the current color // onto a stack so that the state can later // be restored by calling Pop(). Push() // Pop restores the context saved by the // corresponding call to Push(). Pop() // Stroke strokes the given path. Stroke(Path) // Fill fills the given path. Fill(Path) // FillString fills in text at the specified // location using the given font. // If the font size is zero, the text is not drawn. FillString(f font.Face, pt Point, text string) // DrawImage draws the image, scaled to fit // the destination rectangle. DrawImage(rect Rectangle, img image.Image) }
A Canvas is the main drawing interface for 2D vector graphics. The origin is in the bottom left corner.
func MultiCanvas ¶
MultiCanvas creates a canvas that duplicates its drawing operations to all the provided canvases, similar to the Unix tee(1) command.
Each drawing operation is sent to each listed canvas, one at a time.
type CanvasSizer ¶
CanvasSizer is a Canvas with a defined size.
type CanvasWriterTo ¶
type CanvasWriterTo interface { CanvasSizer io.WriterTo }
CanvasWriterTo is a CanvasSizer with a WriteTo method.
type Length ¶
A Length is a unit-independent representation of length. Internally, the length is stored in postscript points.
func ParseLength ¶
ParseLength parses a Length string. A Length string is a possible signed floating number with a unit. e.g. "42cm" "2.4in" "66pt" If no unit was given, ParseLength assumes it was (postscript) points. Currently valid units are:
- mm (millimeter)
- cm (centimeter)
- in (inch)
- pt (point)
func Points ¶
Points returns a length for the given number of points.
type Path ¶
type Path []PathComp
func (*Path) Arc ¶
Arc adds an arc to the path defined by the center point of the arc's circle, the radius of the circle and the start and sweep angles.
func (*Path) Close ¶
func (p *Path) Close()
Close closes the path by connecting the current location to the start location with a line.
func (*Path) CubeTo ¶
CubeTo adds a cubic curve element to the path, given by the control points p1 and p2 and the end point pt.
func (*Path) Line ¶
Line draws a line from the current point to the given point.
func (*Path) Move ¶
Move moves the current location of the path to the given point.
func (*Path) QuadTo ¶
QuadTo adds a quadratic curve element to the path, given by the control point p1 and end point pt.
type PathComp ¶
type PathComp struct { // Type is the type of a particluar component. // Based on the type, each of the following // fields may have a different meaning or may // be meaningless. Type int // The Pos field is used as the destination // of a MoveComp or LineComp and is the center // point of an ArcComp. It is not used in // the CloseComp. Pos Point // Control is one or two intermediate points // for a CurveComp used by QuadTo and CubeTo. Control []Point // Radius is only used for ArcComps, it is // the radius of the circle defining the arc. Radius Length // Start and Angle are only used for ArcComps. // They define the start angle and sweep angle of // the arc around the circle. The units of the // angle are radians. Start, Angle float64 }
A PathComp is a component of a path structure.
type Point ¶
type Point struct { X, Y Length }
A Point is a location in 2d space.
Points are used for drawing, not for data. For data, see the XYer interface.
func (Point) Add ¶
Add returns the component-wise sum of two points.
func (Point) Dot ¶
Dot returns the dot product of two points.
func (Point) Scale ¶
Scale returns the component-wise product of a point and a scalar.
func (Point) Sub ¶
Sub returns the component-wise difference of two points.
type Rectangle ¶
A Rectangle represents a rectangular region of 2d space.
func (Rectangle) Add ¶
Add returns the rectangle r translated by p.
func (Rectangle) Path ¶
Path returns the path of a Rect specified by its upper left corner, width and height.
func (Rectangle) Size ¶
Size returns the width and height of a Rectangle.
Source Files ¶
geom.go len.go tee.go vg.go
Directories ¶
Path | Synopsis |
---|---|
vg/draw | Package draw provides types and functions to draw shapes on a vg.Canvas. |
vg/recorder | Package recorder provides support for vector graphics serialization. |
vg/vgeps | Package vgeps implements the vg.Canvas interface using encapsulated postscript. |
vg/vggio | Package vggio provides a vg.Canvas implementation backed by Gio, a toolkit that implements portable immediate GUI mode in Go. |
vg/vgimg | Package vgimg implements the vg.Canvas interface using git.sr.ht/~sbinet/gg as a backend to output raster images. |
vg/vgpdf | Package vgpdf implements the vg.Canvas interface using gofpdf (github.com/phpdave11/gofpdf). |
vg/vgsvg | Package vgsvg uses svgo (github.com/ajstarks/svgo) as a backend for vg. |
vg/vgtex | Package vgtex provides a vg.Canvas implementation for LaTeX, targeted at the TikZ/PGF LaTeX package: https://sourceforge.net/projects/pgf |
- Version
- v0.15.0 (latest)
- Published
- Oct 22, 2024
- Platform
- linux/amd64
- Imports
- 4 packages
- Last checked
- 1 week ago –
Tools for package owners.