Package vg

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

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

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

Constants

Common lengths.

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

Constants that tag the type of each path component.

const (
    MoveComp = iota
    LineComp
    ArcComp
    CurveComp
    CloseComp
)

func Initialize ¶

func Initialize(c Canvas)

Initialize sets all of the canvas's values to their initial values.

type Canvas ¶

A Canvas is the main drawing interface for 2D vector graphics. The origin is in the bottom left corner.

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

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 ¶

CanvasSizer is a Canvas with a defined size.

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

type CanvasWriterTo ¶

CanvasWriterTo is a CanvasSizer with a WriteTo method.

type CanvasWriterTo interface {
    CanvasSizer
    io.WriterTo
}

type Length ¶

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

type Length = font.Length

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 ¶

A PathComp is a component of a path structure.

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
}

type Point ¶

A Point is a location in 2d space.

Points are used for drawing, not for data. For data, see the XYer interface.

type Point struct {
    X, Y Length
}

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 ¶

A Rectangle represents a rectangular region of 2d space.

type Rectangle struct {
    Min Point
    Max Point
}

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.

Subdirectories