Documentation

Overview

    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.

    Example (AddFont)
    Output:
    
    
    Example (InMemoryCanvas)
    Output:
    
    
    Example (WriterToCanvas)
    Output:
    
    

    Index

    Examples

    Constants

    View Source
    const (
    	Inch       = font.Inch
    	Centimeter = font.Centimeter
    	Millimeter = font.Millimeter
    )

      Common lengths.

      View Source
      const (
      	MoveComp = iota
      	LineComp
      	ArcComp
      	CurveComp
      	CloseComp
      )

        Constants that tag the type of each path component.

        Variables

        View Source
        var FontDirs []string

          FontDirs is a slice of directories searched for font data files. If the first font file found is unreadable or cannot be parsed, then subsequent directories are not tried, and the font will fail to load.

          The default slice is initialised with the contents of the VGFONTPATH environment variable if it is defined. This slice may be changed to load fonts from different locations.

          View Source
          var (
          	// FontMap maps Postscript/PDF font names to compatible
          	// free fonts (OpenType converted ghostscript fonts).
          	// Fonts that are not keys of this map are not supported.
          	FontMap = map[string]string{
          
          		"Courier":             "LiberationMono-Regular",
          		"Courier-Bold":        "LiberationMono-Bold",
          		"Courier-Oblique":     "LiberationMono-Italic",
          		"Courier-BoldOblique": "LiberationMono-BoldItalic",
          
          		"Helvetica":             "LiberationSans-Regular",
          		"Helvetica-Bold":        "LiberationSans-Bold",
          		"Helvetica-Oblique":     "LiberationSans-Italic",
          		"Helvetica-BoldOblique": "LiberationSans-BoldItalic",
          
          		"Times-Roman":      "LiberationSerif-Regular",
          		"Times-Bold":       "LiberationSerif-Bold",
          		"Times-Italic":     "LiberationSerif-Italic",
          		"Times-BoldItalic": "LiberationSerif-BoldItalic",
          
          		"LiberationMono-Regular":    "LiberationMono-Regular",
          		"LiberationMono-Bold":       "LiberationMono-Bold",
          		"LiberationMono-Italic":     "LiberationMono-Italic",
          		"LiberationMono-BoldItalic": "LiberationMono-BoldItalic",
          
          		"LiberationSans-Regular":    "LiberationSans-Regular",
          		"LiberationSans-Bold":       "LiberationSans-Bold",
          		"LiberationSans-Italic":     "LiberationSans-Italic",
          		"LiberationSans-BoldItalic": "LiberationSans-BoldItalic",
          
          		"LiberationSerif-Regular":    "LiberationSerif-Regular",
          		"LiberationSerif-Bold":       "LiberationSerif-Bold",
          		"LiberationSerif-Italic":     "LiberationSerif-Italic",
          		"LiberationSerif-BoldItalic": "LiberationSerif-BoldItalic",
          	}
          )

          Functions

          func AddFont

          func AddFont(name string, font *opentype.Font)

            AddFont associates an opentype.Font with the given name.

            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

                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.

                  type CanvasSizer

                  type CanvasSizer interface {
                  	Canvas
                  	Size() (x, y Length)
                  }

                    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 Font

                      type Font struct {
                      	// Size is the size of the font.  The font size can
                      	// be used as a reasonable value for the vertical
                      	// distance between two successive lines of text.
                      	Size Length
                      	// contains filtered or unexported fields
                      }

                        A Font represents one of the supported font faces.

                        func MakeFont

                        func MakeFont(name string, size Length) (font Font, err error)

                          MakeFont returns a font object. The name of the font must be a key of the FontMap. The font file is located by searching the FontDirs slice for a directory containing the relevant font file. The font file name is name mapped by FontMap with the .ttf extension. For example, the font file for the font name Courier is LiberationMono-Regular.ttf.

                          func (*Font) Extents

                          func (f *Font) Extents() FontExtents

                            Extents returns the FontExtents for a font.

                            func (*Font) Font

                            func (f *Font) Font() *opentype.Font

                              Font returns the corresponding opentype.Font.

                              func (*Font) FontFace

                              func (f *Font) FontFace(dpi float64) font.Face

                              func (*Font) Name

                              func (f *Font) Name() string

                                Name returns the name of the font.

                                func (*Font) SetName

                                func (f *Font) SetName(name string) error

                                  SetName sets the name of the font, effectively changing the font. If an error is returned then the font is left unchanged.

                                  func (*Font) Width

                                  func (f *Font) Width(s string) Length

                                    Width returns width of a string when drawn using the font.

                                    type FontExtents

                                    type FontExtents struct {
                                    	// Ascent is the distance that the text
                                    	// extends above the baseline.
                                    	Ascent Length
                                    
                                    	// Descent is the distance that the text
                                    	// extends below the baseline.  The descent
                                    	// is given as a positive value.
                                    	Descent Length
                                    
                                    	// Height is the distance from the lowest
                                    	// descending point to the highest ascending
                                    	// point.
                                    	Height Length
                                    }

                                      FontExtents contains font metric information.

                                      type Length

                                      type Length = font.Length

                                        A Length is a unit-independent representation of length. Internally, the length is stored in postscript points.

                                        func ParseLength

                                        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

                                          func Points(pt float64) Length

                                            Points returns a length for the given number of points.

                                            type Path

                                            type Path []PathComp

                                            func (*Path) Arc

                                            func (p *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.

                                              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

                                                func (p *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.

                                                  func (*Path) Line

                                                  func (p *Path) Line(pt Point)

                                                    Line draws a line from the current point to the given point.

                                                    func (*Path) Move

                                                    func (p *Path) Move(pt Point)

                                                      Move moves the current location of the path to the given point.

                                                      func (*Path) QuadTo

                                                      func (p *Path) QuadTo(p1, pt Point)

                                                        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

                                                            func (p Point) Add(q Point) Point

                                                              Add returns the component-wise sum of two points.

                                                              func (Point) Dot

                                                              func (p Point) Dot(q Point) Length

                                                                Dot returns the dot product of two points.

                                                                func (Point) Scale

                                                                func (p Point) Scale(s Length) Point

                                                                  Scale returns the component-wise product of a point and a scalar.

                                                                  func (Point) Sub

                                                                  func (p Point) Sub(q Point) Point

                                                                    Sub returns the component-wise difference of two points.

                                                                    type Rectangle

                                                                    type Rectangle struct {
                                                                    	Min Point
                                                                    	Max Point
                                                                    }

                                                                      A Rectangle represents a rectangular region of 2d space.

                                                                      func (Rectangle) Path

                                                                      func (r Rectangle) Path() (p Path)

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

                                                                        func (Rectangle) Size

                                                                        func (r Rectangle) Size() Point

                                                                          Size returns the width and height of a Rectangle.

                                                                          Directories

                                                                          Path Synopsis
                                                                          Package draw provides types and functions to draw shapes on a vg.Canvas.
                                                                          Package draw provides types and functions to draw shapes on a vg.Canvas.
                                                                          Package fonts provides the Liberation fonts from https://fedorahosted.org/liberation-fonts/
                                                                          Package fonts provides the Liberation fonts from https://fedorahosted.org/liberation-fonts/
                                                                          Package recorder provides support for vector graphics serialization.
                                                                          Package recorder provides support for vector graphics serialization.
                                                                          Package vgeps implements the vg.Canvas interface using encapsulated postscript.
                                                                          Package vgeps implements the vg.Canvas interface using encapsulated postscript.
                                                                          Package vggio provides a vg.Canvas implementation backed by Gio, a toolkit that implements portable immediate GUI mode in Go.
                                                                          Package vggio provides a vg.Canvas implementation backed by Gio, a toolkit that implements portable immediate GUI mode in Go.
                                                                          Package vgimg implements the vg.Canvas interface using github.com/fogleman/gg as a backend to output raster images.
                                                                          Package vgimg implements the vg.Canvas interface using github.com/fogleman/gg as a backend to output raster images.
                                                                          Package vgpdf implements the vg.Canvas interface using gofpdf (github.com/phpdave11/gofpdf).
                                                                          Package vgpdf implements the vg.Canvas interface using gofpdf (github.com/phpdave11/gofpdf).
                                                                          Package vgsvg uses svgo (github.com/ajstarks/svgo) as a backend for vg.
                                                                          Package vgsvg uses svgo (github.com/ajstarks/svgo) as a backend for vg.
                                                                          Package vgtex provides a vg.Canvas implementation for LaTeX, targeted at the TikZ/PGF LaTeX package: https://sourceforge.net/projects/pgf vgtex generates PGF instructions that will be interpreted and rendered by LaTeX. vgtex allows to put any valid LaTeX notation inside plot's strings.
                                                                          Package vgtex provides a vg.Canvas implementation for LaTeX, targeted at the TikZ/PGF LaTeX package: https://sourceforge.net/projects/pgf vgtex generates PGF instructions that will be interpreted and rendered by LaTeX. vgtex allows to put any valid LaTeX notation inside plot's strings.