package vg

Import Path
	gonum.org/v1/plot/vg (on go.dev)

Dependency Relation
	imports 4 packages, and imported by 2 packages

Involved Source Files

	    geom.go
	    len.go
	    tee.go
	  d vg.go
		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 Examples

	_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
			}
		}

	_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)
			}
		}

	_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)
			}
		}


Package-Level Type Names (total 8)

	/* sort by: alphabet | popularity */
	 type Canvas (interface)
		A Canvas is the main drawing interface for 2D vector
		graphics.
		The origin is in the bottom left corner.

		Methods (total 12)
			( Canvas) DrawImage(rect Rectangle, img image.Image)
				DrawImage draws the image, scaled to fit
				the destination rectangle.

			( Canvas) Fill(Path)
				Fill fills the given path.

			( Canvas) FillString(f font.Face, pt Point, text string)
				FillString fills in text at the specified
				location using the given font.
				If the font size is zero, the text is not drawn.

			( Canvas) Pop()
				Pop restores the context saved by the
				corresponding call to Push().

			( Canvas) Push()
				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().

			( Canvas) Rotate(rad float64)
				Rotate applies a rotation transform to the context.
				The parameter is specified in radians.

			( Canvas) Scale(x, y float64)
				Scale applies a scaling transform to the
				context.

			( Canvas) SetColor(color.Color)
				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.

			( Canvas) SetLineDash(pattern []Length, offset 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.

			( Canvas) SetLineWidth(Length)
				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.

			( Canvas) Stroke(Path)
				Stroke strokes the given path.

			( Canvas) Translate(pt Point)
				Translate applies a translational transform
				to the context.

		Implemented By (at least 2)
			 CanvasSizer (interface)
			 CanvasWriterTo (interface)
		As Outputs Of (at least one exported)
			func MultiCanvas(cs ...Canvas) Canvas
		As Inputs Of (at least 2)
			func Initialize(c Canvas)
			func MultiCanvas(cs ...Canvas) Canvas

	 type CanvasSizer (interface)
		CanvasSizer is a Canvas with a defined size.

		Methods (total 13)
			( CanvasSizer) DrawImage(rect Rectangle, img image.Image)
				DrawImage draws the image, scaled to fit
				the destination rectangle.

			( CanvasSizer) Fill(Path)
				Fill fills the given path.

			( CanvasSizer) FillString(f font.Face, pt Point, text string)
				FillString fills in text at the specified
				location using the given font.
				If the font size is zero, the text is not drawn.

			( CanvasSizer) Pop()
				Pop restores the context saved by the
				corresponding call to Push().

			( CanvasSizer) Push()
				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().

			( CanvasSizer) Rotate(rad float64)
				Rotate applies a rotation transform to the context.
				The parameter is specified in radians.

			( CanvasSizer) Scale(x, y float64)
				Scale applies a scaling transform to the
				context.

			( CanvasSizer) SetColor(color.Color)
				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.

			( CanvasSizer) SetLineDash(pattern []Length, offset 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.

			( CanvasSizer) SetLineWidth(Length)
				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.

			( CanvasSizer) Size() (x, y Length)
			( CanvasSizer) Stroke(Path)
				Stroke strokes the given path.

			( CanvasSizer) Translate(pt Point)
				Translate applies a translational transform
				to the context.

		Implemented By (at least one exported)
			 CanvasWriterTo (interface)
		Implements (at least one exported)
			 CanvasSizer : Canvas

	 type CanvasWriterTo (interface)
		CanvasWriterTo is a CanvasSizer with a WriteTo method.

		Methods (total 14)
			( CanvasWriterTo) DrawImage(rect Rectangle, img image.Image)
				DrawImage draws the image, scaled to fit
				the destination rectangle.

			( CanvasWriterTo) Fill(Path)
				Fill fills the given path.

			( CanvasWriterTo) FillString(f font.Face, pt Point, text string)
				FillString fills in text at the specified
				location using the given font.
				If the font size is zero, the text is not drawn.

			( CanvasWriterTo) Pop()
				Pop restores the context saved by the
				corresponding call to Push().

			( CanvasWriterTo) Push()
				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().

			( CanvasWriterTo) Rotate(rad float64)
				Rotate applies a rotation transform to the context.
				The parameter is specified in radians.

			( CanvasWriterTo) Scale(x, y float64)
				Scale applies a scaling transform to the
				context.

			( CanvasWriterTo) SetColor(color.Color)
				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.

			( CanvasWriterTo) SetLineDash(pattern []Length, offset 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.

			( CanvasWriterTo) SetLineWidth(Length)
				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.

			( CanvasWriterTo) Size() (x, y Length)
			( CanvasWriterTo) Stroke(Path)
				Stroke strokes the given path.

			( CanvasWriterTo) Translate(pt Point)
				Translate applies a translational transform
				to the context.

			( CanvasWriterTo) WriteTo(w io.Writer) (n int64, err error)
		Implements (at least 4)
			 CanvasWriterTo : Canvas
			 CanvasWriterTo : CanvasSizer
			 CanvasWriterTo : github.com/gobwas/ws.HandshakeHeader
			 CanvasWriterTo : io.WriterTo

	 type Length = font.Length (basic type)
		A Length is a unit-independent representation of length.
		Internally, the length is stored in postscript points.

	 type Path ([])

		Methods (total 6)
			(*Path) Arc(pt Point, rad Length, s, a float64)
				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.

			(*Path) Close()
				Close closes the path by connecting the current
				location to the start location with a line.

			(*Path) CubeTo(p1, p2, pt Point)
				CubeTo adds a cubic curve element to the path,
				given by the control points p1 and p2 and the end point pt.

			(*Path) Line(pt Point)
				Line draws a line from the current point to the
				given point.

			(*Path) Move(pt Point)
				Move moves the current location of the path to
				the given point.

			(*Path) QuadTo(p1, pt Point)
				QuadTo adds a quadratic curve element to the path,
				given by the control point p1 and end point pt.

		As Outputs Of (at least one exported)
			func Rectangle.Path() (p Path)
		As Inputs Of (at least 6)
			func Canvas.Fill(Path)
			func Canvas.Stroke(Path)
			func CanvasSizer.Fill(Path)
			func CanvasSizer.Stroke(Path)
			func CanvasWriterTo.Fill(Path)
			func CanvasWriterTo.Stroke(Path)

	 type PathComp (struct)
		A PathComp is a component of a path structure.

		Fields (total 6)
			Angle float64
				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.

			Control []Point
				Control is one or two intermediate points
				for a CurveComp used by QuadTo and CubeTo.

			Pos Point
				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.

			Radius Length
				Radius is only used for ArcComps, it is
				the radius of the circle defining the arc.

			Start float64
				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.

			Type int
				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 Point (struct)
		A Point is a location in 2d space.
		
		Points are used for drawing, not for data.  For
		data, see the XYer interface.

		Fields (total 2)
			X Length
			Y Length
		Methods (total 4)
			( Point) Add(q Point) Point
				Add returns the component-wise sum of two points.

			( Point) Dot(q Point) Length
				Dot returns the dot product of two points.

			( Point) Scale(s Length) Point
				Scale returns the component-wise product of a point and a scalar.

			( Point) Sub(q Point) Point
				Sub returns the component-wise difference of two points.

		As Outputs Of (at least 6)
			func Point.Add(q Point) Point
			func Point.Scale(s Length) Point
			func Point.Sub(q Point) Point
			func Rectangle.Size() Point
			func gonum.org/v1/plot/tools/bezier.Curve.Curve(p []Point) []Point
			func gonum.org/v1/plot/tools/bezier.Curve.Point(t float64) Point
		As Inputs Of (at least 17)
			func Canvas.FillString(f font.Face, pt Point, text string)
			func Canvas.Translate(pt Point)
			func CanvasSizer.FillString(f font.Face, pt Point, text string)
			func CanvasSizer.Translate(pt Point)
			func CanvasWriterTo.FillString(f font.Face, pt Point, text string)
			func CanvasWriterTo.Translate(pt Point)
			func (*Path).Arc(pt Point, rad Length, s, a float64)
			func (*Path).CubeTo(p1, p2, pt Point)
			func (*Path).Line(pt Point)
			func (*Path).Move(pt Point)
			func (*Path).QuadTo(p1, pt Point)
			func Point.Add(q Point) Point
			func Point.Dot(q Point) Length
			func Point.Sub(q Point) Point
			func Rectangle.Add(p Point) Rectangle
			func gonum.org/v1/plot/tools/bezier.New(cp ...Point) bezier.Curve
			func gonum.org/v1/plot/tools/bezier.Curve.Curve(p []Point) []Point

	 type Rectangle (struct)
		A Rectangle represents a rectangular region of 2d space.

		Fields (total 2)
			Max Point
			Min Point
		Methods (total 3)
			( Rectangle) Add(p Point) Rectangle
				Add returns the rectangle r translated by p.

			( Rectangle) Path() (p Path)
				Path returns the path of a Rect specified by its
				upper left corner, width and height.

			( Rectangle) Size() Point
				Size returns the width and height of a Rectangle.

		As Outputs Of (at least one exported)
			func Rectangle.Add(p Point) Rectangle
		As Inputs Of (at least 3)
			func Canvas.DrawImage(rect Rectangle, img image.Image)
			func CanvasSizer.DrawImage(rect Rectangle, img image.Image)
			func CanvasWriterTo.DrawImage(rect Rectangle, img image.Image)


Package-Level Functions (total 4)

	 func Initialize(c Canvas)
		Initialize sets all of the canvas's values to their
		initial values.

	 func MultiCanvas(cs ...Canvas) Canvas
		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.

	 func ParseLength(value string) (Length, error)
		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(pt float64) Length
		Points returns a length for the given number of points.


Package-Level Constants (total 8)

	const ArcComp = 2
		Constants that tag the type of each path
		component.

	const Centimeter font.Length = 28.3465
		Common lengths.

	const CloseComp = 4
		Constants that tag the type of each path
		component.

	const CurveComp = 3
		Constants that tag the type of each path
		component.

	const Inch font.Length = 72
		Common lengths.

	const LineComp = 1
		Constants that tag the type of each path
		component.

	const Millimeter font.Length = 2.83465
		Common lengths.

	const MoveComp = 0
		Constants that tag the type of each path
		component.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.