vg

package
v0.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 5, 2022 License: BSD-3-Clause Imports: 4 Imported by: 0

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) 
package main

import (
	"archive/tar"
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"log"
	"net/http"

	"golang.org/x/image/font/opentype"

	"github.com/gopherd/plot"
	"github.com/gopherd/plot/font"
	"github.com/gopherd/plot/plotter"
	"github.com/gopherd/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"

	"github.com/gopherd/plot"
	"github.com/gopherd/plot/plotter"
	"github.com/gopherd/plot/vg"
	"github.com/gopherd/plot/vg/draw"
	"github.com/gopherd/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"

	"github.com/gopherd/plot"
	"github.com/gopherd/plot/plotter"
	"github.com/gopherd/plot/vg"
	"github.com/gopherd/plot/vg/draw"
	"github.com/gopherd/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

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

This section is empty.

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 

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 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) Add 

func (r Rectangle) Add(p Point) Rectangle

Add returns the rectangle r translated by p.

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.

Source Files

View all Source files

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 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 vgimg implements the vg.Canvas interface using git.sr.ht/~sbinet/gg as a backend to output raster images.
 Package vgimg implements the vg.Canvas interface using git.sr.ht/~sbinet/gg as a backend to output raster images.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.