canvas: github.com/tdewolff/canvas Index | Files | Directories

package canvas

import "github.com/tdewolff/canvas"

Index

Package Files

canvas.go colors.go font.go fontface.go gochart.go gonumplot.go latex.go opengl.go path.go path_intersection.go path_stroke.go path_tessellation.go path_util.go polyline.go shapes.go tex.go text.go util.go

Constants

const DPI = DPMM(1 / 25.4)

DPI is a shortcut for Dots-per-Inch for the resolution of raster images.

const MaxGlyphSpacing = 0.5

MaxGlyphSpacing is the maximum amount times the x-height of the font that glyphs can be spaced.

const MaxSentenceSpacing = 3.5

MaxSentenceSpacing is the maximum amount times the x-height of the font that sentence spaces can expand.

const MaxWordSpacing = 2.5

MaxWordSpacing is the maximum amount times the x-height of the font that word spaces can expand.

Variables

var (
    Aliceblue            = color.RGBA{0xf0, 0xf8, 0xff, 0xff} // rgb(240, 248, 255)
    Antiquewhite         = color.RGBA{0xfa, 0xeb, 0xd7, 0xff} // rgb(250, 235, 215)
    Aqua                 = color.RGBA{0x00, 0xff, 0xff, 0xff} // rgb(0, 255, 255)
    Aquamarine           = color.RGBA{0x7f, 0xff, 0xd4, 0xff} // rgb(127, 255, 212)
    Azure                = color.RGBA{0xf0, 0xff, 0xff, 0xff} // rgb(240, 255, 255)
    Beige                = color.RGBA{0xf5, 0xf5, 0xdc, 0xff} // rgb(245, 245, 220)
    Bisque               = color.RGBA{0xff, 0xe4, 0xc4, 0xff} // rgb(255, 228, 196)
    Black                = color.RGBA{0x00, 0x00, 0x00, 0xff} // rgb(0, 0, 0)
    Blanchedalmond       = color.RGBA{0xff, 0xeb, 0xcd, 0xff} // rgb(255, 235, 205)
    Blue                 = color.RGBA{0x00, 0x00, 0xff, 0xff} // rgb(0, 0, 255)
    Blueviolet           = color.RGBA{0x8a, 0x2b, 0xe2, 0xff} // rgb(138, 43, 226)
    Brown                = color.RGBA{0xa5, 0x2a, 0x2a, 0xff} // rgb(165, 42, 42)
    Burlywood            = color.RGBA{0xde, 0xb8, 0x87, 0xff} // rgb(222, 184, 135)
    Cadetblue            = color.RGBA{0x5f, 0x9e, 0xa0, 0xff} // rgb(95, 158, 160)
    Chartreuse           = color.RGBA{0x7f, 0xff, 0x00, 0xff} // rgb(127, 255, 0)
    Chocolate            = color.RGBA{0xd2, 0x69, 0x1e, 0xff} // rgb(210, 105, 30)
    Coral                = color.RGBA{0xff, 0x7f, 0x50, 0xff} // rgb(255, 127, 80)
    Cornflowerblue       = color.RGBA{0x64, 0x95, 0xed, 0xff} // rgb(100, 149, 237)
    Cornsilk             = color.RGBA{0xff, 0xf8, 0xdc, 0xff} // rgb(255, 248, 220)
    Crimson              = color.RGBA{0xdc, 0x14, 0x3c, 0xff} // rgb(220, 20, 60)
    Cyan                 = color.RGBA{0x00, 0xff, 0xff, 0xff} // rgb(0, 255, 255)
    Darkblue             = color.RGBA{0x00, 0x00, 0x8b, 0xff} // rgb(0, 0, 139)
    Darkcyan             = color.RGBA{0x00, 0x8b, 0x8b, 0xff} // rgb(0, 139, 139)
    Darkgoldenrod        = color.RGBA{0xb8, 0x86, 0x0b, 0xff} // rgb(184, 134, 11)
    Darkgray             = color.RGBA{0xa9, 0xa9, 0xa9, 0xff} // rgb(169, 169, 169)
    Darkgreen            = color.RGBA{0x00, 0x64, 0x00, 0xff} // rgb(0, 100, 0)
    Darkgrey             = color.RGBA{0xa9, 0xa9, 0xa9, 0xff} // rgb(169, 169, 169)
    Darkkhaki            = color.RGBA{0xbd, 0xb7, 0x6b, 0xff} // rgb(189, 183, 107)
    Darkmagenta          = color.RGBA{0x8b, 0x00, 0x8b, 0xff} // rgb(139, 0, 139)
    Darkolivegreen       = color.RGBA{0x55, 0x6b, 0x2f, 0xff} // rgb(85, 107, 47)
    Darkorange           = color.RGBA{0xff, 0x8c, 0x00, 0xff} // rgb(255, 140, 0)
    Darkorchid           = color.RGBA{0x99, 0x32, 0xcc, 0xff} // rgb(153, 50, 204)
    Darkred              = color.RGBA{0x8b, 0x00, 0x00, 0xff} // rgb(139, 0, 0)
    Darksalmon           = color.RGBA{0xe9, 0x96, 0x7a, 0xff} // rgb(233, 150, 122)
    Darkseagreen         = color.RGBA{0x8f, 0xbc, 0x8f, 0xff} // rgb(143, 188, 143)
    Darkslateblue        = color.RGBA{0x48, 0x3d, 0x8b, 0xff} // rgb(72, 61, 139)
    Darkslategray        = color.RGBA{0x2f, 0x4f, 0x4f, 0xff} // rgb(47, 79, 79)
    Darkslategrey        = color.RGBA{0x2f, 0x4f, 0x4f, 0xff} // rgb(47, 79, 79)
    Darkturquoise        = color.RGBA{0x00, 0xce, 0xd1, 0xff} // rgb(0, 206, 209)
    Darkviolet           = color.RGBA{0x94, 0x00, 0xd3, 0xff} // rgb(148, 0, 211)
    Deeppink             = color.RGBA{0xff, 0x14, 0x93, 0xff} // rgb(255, 20, 147)
    Deepskyblue          = color.RGBA{0x00, 0xbf, 0xff, 0xff} // rgb(0, 191, 255)
    Dimgray              = color.RGBA{0x69, 0x69, 0x69, 0xff} // rgb(105, 105, 105)
    Dimgrey              = color.RGBA{0x69, 0x69, 0x69, 0xff} // rgb(105, 105, 105)
    Dodgerblue           = color.RGBA{0x1e, 0x90, 0xff, 0xff} // rgb(30, 144, 255)
    Firebrick            = color.RGBA{0xb2, 0x22, 0x22, 0xff} // rgb(178, 34, 34)
    Floralwhite          = color.RGBA{0xff, 0xfa, 0xf0, 0xff} // rgb(255, 250, 240)
    Forestgreen          = color.RGBA{0x22, 0x8b, 0x22, 0xff} // rgb(34, 139, 34)
    Fuchsia              = color.RGBA{0xff, 0x00, 0xff, 0xff} // rgb(255, 0, 255)
    Gainsboro            = color.RGBA{0xdc, 0xdc, 0xdc, 0xff} // rgb(220, 220, 220)
    Ghostwhite           = color.RGBA{0xf8, 0xf8, 0xff, 0xff} // rgb(248, 248, 255)
    Gold                 = color.RGBA{0xff, 0xd7, 0x00, 0xff} // rgb(255, 215, 0)
    Goldenrod            = color.RGBA{0xda, 0xa5, 0x20, 0xff} // rgb(218, 165, 32)
    Gray                 = color.RGBA{0x80, 0x80, 0x80, 0xff} // rgb(128, 128, 128)
    Green                = color.RGBA{0x00, 0x80, 0x00, 0xff} // rgb(0, 128, 0)
    Greenyellow          = color.RGBA{0xad, 0xff, 0x2f, 0xff} // rgb(173, 255, 47)
    Grey                 = color.RGBA{0x80, 0x80, 0x80, 0xff} // rgb(128, 128, 128)
    Honeydew             = color.RGBA{0xf0, 0xff, 0xf0, 0xff} // rgb(240, 255, 240)
    Hotpink              = color.RGBA{0xff, 0x69, 0xb4, 0xff} // rgb(255, 105, 180)
    Indianred            = color.RGBA{0xcd, 0x5c, 0x5c, 0xff} // rgb(205, 92, 92)
    Indigo               = color.RGBA{0x4b, 0x00, 0x82, 0xff} // rgb(75, 0, 130)
    Ivory                = color.RGBA{0xff, 0xff, 0xf0, 0xff} // rgb(255, 255, 240)
    Khaki                = color.RGBA{0xf0, 0xe6, 0x8c, 0xff} // rgb(240, 230, 140)
    Lavender             = color.RGBA{0xe6, 0xe6, 0xfa, 0xff} // rgb(230, 230, 250)
    Lavenderblush        = color.RGBA{0xff, 0xf0, 0xf5, 0xff} // rgb(255, 240, 245)
    Lawngreen            = color.RGBA{0x7c, 0xfc, 0x00, 0xff} // rgb(124, 252, 0)
    Lemonchiffon         = color.RGBA{0xff, 0xfa, 0xcd, 0xff} // rgb(255, 250, 205)
    Lightblue            = color.RGBA{0xad, 0xd8, 0xe6, 0xff} // rgb(173, 216, 230)
    Lightcoral           = color.RGBA{0xf0, 0x80, 0x80, 0xff} // rgb(240, 128, 128)
    Lightcyan            = color.RGBA{0xe0, 0xff, 0xff, 0xff} // rgb(224, 255, 255)
    Lightgoldenrodyellow = color.RGBA{0xfa, 0xfa, 0xd2, 0xff} // rgb(250, 250, 210)
    Lightgray            = color.RGBA{0xd3, 0xd3, 0xd3, 0xff} // rgb(211, 211, 211)
    Lightgreen           = color.RGBA{0x90, 0xee, 0x90, 0xff} // rgb(144, 238, 144)
    Lightgrey            = color.RGBA{0xd3, 0xd3, 0xd3, 0xff} // rgb(211, 211, 211)
    Lightpink            = color.RGBA{0xff, 0xb6, 0xc1, 0xff} // rgb(255, 182, 193)
    Lightsalmon          = color.RGBA{0xff, 0xa0, 0x7a, 0xff} // rgb(255, 160, 122)
    Lightseagreen        = color.RGBA{0x20, 0xb2, 0xaa, 0xff} // rgb(32, 178, 170)
    Lightskyblue         = color.RGBA{0x87, 0xce, 0xfa, 0xff} // rgb(135, 206, 250)
    Lightslategray       = color.RGBA{0x77, 0x88, 0x99, 0xff} // rgb(119, 136, 153)
    Lightslategrey       = color.RGBA{0x77, 0x88, 0x99, 0xff} // rgb(119, 136, 153)
    Lightsteelblue       = color.RGBA{0xb0, 0xc4, 0xde, 0xff} // rgb(176, 196, 222)
    Lightyellow          = color.RGBA{0xff, 0xff, 0xe0, 0xff} // rgb(255, 255, 224)
    Lime                 = color.RGBA{0x00, 0xff, 0x00, 0xff} // rgb(0, 255, 0)
    Limegreen            = color.RGBA{0x32, 0xcd, 0x32, 0xff} // rgb(50, 205, 50)
    Linen                = color.RGBA{0xfa, 0xf0, 0xe6, 0xff} // rgb(250, 240, 230)
    Magenta              = color.RGBA{0xff, 0x00, 0xff, 0xff} // rgb(255, 0, 255)
    Maroon               = color.RGBA{0x80, 0x00, 0x00, 0xff} // rgb(128, 0, 0)
    Mediumaquamarine     = color.RGBA{0x66, 0xcd, 0xaa, 0xff} // rgb(102, 205, 170)
    Mediumblue           = color.RGBA{0x00, 0x00, 0xcd, 0xff} // rgb(0, 0, 205)
    Mediumorchid         = color.RGBA{0xba, 0x55, 0xd3, 0xff} // rgb(186, 85, 211)
    Mediumpurple         = color.RGBA{0x93, 0x70, 0xdb, 0xff} // rgb(147, 112, 219)
    Mediumseagreen       = color.RGBA{0x3c, 0xb3, 0x71, 0xff} // rgb(60, 179, 113)
    Mediumslateblue      = color.RGBA{0x7b, 0x68, 0xee, 0xff} // rgb(123, 104, 238)
    Mediumspringgreen    = color.RGBA{0x00, 0xfa, 0x9a, 0xff} // rgb(0, 250, 154)
    Mediumturquoise      = color.RGBA{0x48, 0xd1, 0xcc, 0xff} // rgb(72, 209, 204)
    Mediumvioletred      = color.RGBA{0xc7, 0x15, 0x85, 0xff} // rgb(199, 21, 133)
    Midnightblue         = color.RGBA{0x19, 0x19, 0x70, 0xff} // rgb(25, 25, 112)
    Mintcream            = color.RGBA{0xf5, 0xff, 0xfa, 0xff} // rgb(245, 255, 250)
    Mistyrose            = color.RGBA{0xff, 0xe4, 0xe1, 0xff} // rgb(255, 228, 225)
    Moccasin             = color.RGBA{0xff, 0xe4, 0xb5, 0xff} // rgb(255, 228, 181)
    Navajowhite          = color.RGBA{0xff, 0xde, 0xad, 0xff} // rgb(255, 222, 173)
    Navy                 = color.RGBA{0x00, 0x00, 0x80, 0xff} // rgb(0, 0, 128)
    Oldlace              = color.RGBA{0xfd, 0xf5, 0xe6, 0xff} // rgb(253, 245, 230)
    Olive                = color.RGBA{0x80, 0x80, 0x00, 0xff} // rgb(128, 128, 0)
    Olivedrab            = color.RGBA{0x6b, 0x8e, 0x23, 0xff} // rgb(107, 142, 35)
    Orange               = color.RGBA{0xff, 0xa5, 0x00, 0xff} // rgb(255, 165, 0)
    Orangered            = color.RGBA{0xff, 0x45, 0x00, 0xff} // rgb(255, 69, 0)
    Orchid               = color.RGBA{0xda, 0x70, 0xd6, 0xff} // rgb(218, 112, 214)
    Palegoldenrod        = color.RGBA{0xee, 0xe8, 0xaa, 0xff} // rgb(238, 232, 170)
    Palegreen            = color.RGBA{0x98, 0xfb, 0x98, 0xff} // rgb(152, 251, 152)
    Paleturquoise        = color.RGBA{0xaf, 0xee, 0xee, 0xff} // rgb(175, 238, 238)
    Palevioletred        = color.RGBA{0xdb, 0x70, 0x93, 0xff} // rgb(219, 112, 147)
    Papayawhip           = color.RGBA{0xff, 0xef, 0xd5, 0xff} // rgb(255, 239, 213)
    Peachpuff            = color.RGBA{0xff, 0xda, 0xb9, 0xff} // rgb(255, 218, 185)
    Peru                 = color.RGBA{0xcd, 0x85, 0x3f, 0xff} // rgb(205, 133, 63)
    Pink                 = color.RGBA{0xff, 0xc0, 0xcb, 0xff} // rgb(255, 192, 203)
    Plum                 = color.RGBA{0xdd, 0xa0, 0xdd, 0xff} // rgb(221, 160, 221)
    Powderblue           = color.RGBA{0xb0, 0xe0, 0xe6, 0xff} // rgb(176, 224, 230)
    Purple               = color.RGBA{0x80, 0x00, 0x80, 0xff} // rgb(128, 0, 128)
    Red                  = color.RGBA{0xff, 0x00, 0x00, 0xff} // rgb(255, 0, 0)
    Rosybrown            = color.RGBA{0xbc, 0x8f, 0x8f, 0xff} // rgb(188, 143, 143)
    Royalblue            = color.RGBA{0x41, 0x69, 0xe1, 0xff} // rgb(65, 105, 225)
    Saddlebrown          = color.RGBA{0x8b, 0x45, 0x13, 0xff} // rgb(139, 69, 19)
    Salmon               = color.RGBA{0xfa, 0x80, 0x72, 0xff} // rgb(250, 128, 114)
    Sandybrown           = color.RGBA{0xf4, 0xa4, 0x60, 0xff} // rgb(244, 164, 96)
    Seagreen             = color.RGBA{0x2e, 0x8b, 0x57, 0xff} // rgb(46, 139, 87)
    Seashell             = color.RGBA{0xff, 0xf5, 0xee, 0xff} // rgb(255, 245, 238)
    Sienna               = color.RGBA{0xa0, 0x52, 0x2d, 0xff} // rgb(160, 82, 45)
    Silver               = color.RGBA{0xc0, 0xc0, 0xc0, 0xff} // rgb(192, 192, 192)
    Skyblue              = color.RGBA{0x87, 0xce, 0xeb, 0xff} // rgb(135, 206, 235)
    Slateblue            = color.RGBA{0x6a, 0x5a, 0xcd, 0xff} // rgb(106, 90, 205)
    Slategray            = color.RGBA{0x70, 0x80, 0x90, 0xff} // rgb(112, 128, 144)
    Slategrey            = color.RGBA{0x70, 0x80, 0x90, 0xff} // rgb(112, 128, 144)
    Snow                 = color.RGBA{0xff, 0xfa, 0xfa, 0xff} // rgb(255, 250, 250)
    Springgreen          = color.RGBA{0x00, 0xff, 0x7f, 0xff} // rgb(0, 255, 127)
    Steelblue            = color.RGBA{0x46, 0x82, 0xb4, 0xff} // rgb(70, 130, 180)
    Tan                  = color.RGBA{0xd2, 0xb4, 0x8c, 0xff} // rgb(210, 180, 140)
    Teal                 = color.RGBA{0x00, 0x80, 0x80, 0xff} // rgb(0, 128, 128)
    Thistle              = color.RGBA{0xd8, 0xbf, 0xd8, 0xff} // rgb(216, 191, 216)
    Tomato               = color.RGBA{0xff, 0x63, 0x47, 0xff} // rgb(255, 99, 71)
    Turquoise            = color.RGBA{0x40, 0xe0, 0xd0, 0xff} // rgb(64, 224, 208)
    Violet               = color.RGBA{0xee, 0x82, 0xee, 0xff} // rgb(238, 130, 238)
    Wheat                = color.RGBA{0xf5, 0xde, 0xb3, 0xff} // rgb(245, 222, 179)
    White                = color.RGBA{0xff, 0xff, 0xff, 0xff} // rgb(255, 255, 255)
    Whitesmoke           = color.RGBA{0xf5, 0xf5, 0xf5, 0xff} // rgb(245, 245, 245)
    Yellow               = color.RGBA{0xff, 0xff, 0x00, 0xff} // rgb(255, 255, 0)
    Yellowgreen          = color.RGBA{0x9a, 0xcd, 0x32, 0xff} // rgb(154, 205, 50)
)

from https://golang.org/x/image/colornames

var DefaultStyle = Style{
    FillColor:    Black,
    StrokeColor:  Transparent,
    StrokeWidth:  1.0,
    StrokeCapper: ButtCap,
    StrokeJoiner: MiterJoin,
    DashOffset:   0.0,
    Dashes:       []float64{},
    FillRule:     NonZero,
}

DefaultStyle is the default style for paths. It fills the path with a black color.

var Epsilon = 1e-10

Epsilon is the smallest number below which we assume the value to be zero. This is to avoid numerical floating point issues.

var Identity = Matrix{
    {1.0, 0.0, 0.0},
    {0.0, 1.0, 0.0},
}

Identity is the identity affine transformation matrix, ie. transforms any point to itself.

var Precision = 8

Precision is the number of significant digits at which floating point value will be printed to output formats.

var Tolerance = 0.01

Tolerance is the maximum deviation from the original path in millimeters when e.g. flatting

var Transparent = color.RGBA{0x00, 0x00, 0x00, 0x00} // rgba(0, 0, 0, 0)

Transparent when used as a fill or stroke color will indicate that the fill or stroke will not be drawn.

func Equal Uses

func Equal(a, b float64) bool

Equal returns true if a and b are Equal with tolerance Epsilon.

func NewGoChart Uses

func NewGoChart(writer Writer) func(int, int) (chart.Renderer, error)

NewGoChart returns a new github.com/wcharczuk/go-chart renderer.

func NewGonumPlot Uses

func NewGonumPlot(r Renderer) draw.Canvas

NewGonumPlot returns a new github.com/gonum/plot/vg renderer.

type ArcsJoiner Uses

type ArcsJoiner struct {
    GapJoiner Joiner
    Limit     float64
}

ArcsJoiner is an arcs joiner.

func (ArcsJoiner) Join Uses

func (j ArcsJoiner) Join(rhs, lhs *Path, halfWidth float64, pivot, n0, n1 Point, r0, r1 float64)

Join adds a join to a right-hand-side and left-hand-side path, of width 2*halfWidth, around a pivot point with starting and ending normals of n0 and n1, and radius of curvatures of the previous and next segments.

func (ArcsJoiner) String Uses

func (j ArcsJoiner) String() string

type BevelJoiner Uses

type BevelJoiner struct{}

BevelJoiner is a bevel joiner.

func (BevelJoiner) Join Uses

func (BevelJoiner) Join(rhs, lhs *Path, halfWidth float64, pivot, n0, n1 Point, r0, r1 float64)

Join adds a join to a right-hand-side and left-hand-side path, of width 2*halfWidth, around a pivot point with starting and ending normals of n0 and n1, and radius of curvatures of the previous and next segments.

func (BevelJoiner) String Uses

func (BevelJoiner) String() string

type ButtCapper Uses

type ButtCapper struct{}

ButtCapper is a butt capper.

func (ButtCapper) Cap Uses

func (ButtCapper) Cap(p *Path, halfWidth float64, pivot, n0 Point)

Cap adds a cap to path p of width 2*halfWidth, at a pivot point and initial normal direction of n0.

func (ButtCapper) String Uses

func (ButtCapper) String() string

type CSSColor Uses

type CSSColor color.RGBA

CSSColor is a string formatter to convert a color.RGBA to a CSS color (hexadecimal or using rgba()).

func (CSSColor) String Uses

func (color CSSColor) String() string

type Canvas Uses

type Canvas struct {
    W, H float64
    // contains filtered or unexported fields
}

Canvas stores all drawing operations as layers that can be re-rendered to other renderers.

func New Uses

func New(width, height float64) *Canvas

New returns a new Canvas that records all drawing operations into layers. The canvas can then be rendered to any other renderer.

func (*Canvas) Empty Uses

func (c *Canvas) Empty() bool

Empty return true if the canvas is empty.

func (*Canvas) Fit Uses

func (c *Canvas) Fit(margin float64)

Fit shrinks the canvas size so all elements fit. The elements are translated towards the origin when any left/bottom margins exist and the canvas size is decreased if any margins exist. It will maintain a given margin.

func (*Canvas) Render Uses

func (c *Canvas) Render(r Renderer)

Render renders the accumulated canvas drawing operations to another renderer.

func (*Canvas) RenderImage Uses

func (c *Canvas) RenderImage(img image.Image, m Matrix)

RenderImage renders an image to the canvas using a transformation matrix.

func (*Canvas) RenderPath Uses

func (c *Canvas) RenderPath(path *Path, style Style, m Matrix)

RenderPath renders a path to the canvas using a style and a transformation matrix.

func (*Canvas) RenderText Uses

func (c *Canvas) RenderText(text *Text, m Matrix)

RenderText renders a text object to the canvas using a transformation matrix.

func (*Canvas) Reset Uses

func (c *Canvas) Reset()

Reset empties the canvas.

func (*Canvas) Size Uses

func (c *Canvas) Size() (float64, float64)

Size returns the size of the canvas in mm.

func (*Canvas) WriteFile Uses

func (c *Canvas) WriteFile(filename string, w Writer) error

WriteFile writes the canvas to a file named by filename using the given Writer (for the encoding).

type Capper Uses

type Capper interface {
    Cap(*Path, float64, Point, Point)
}

Capper implements Cap, with rhs the path to append to, halfWidth the half width of the stroke, pivot the pivot point around which to construct a cap, and n0 the normal at the start of the path. The length of n0 is equal to the halfWidth.

var ButtCap Capper = ButtCapper{}

ButtCap caps the start or end of a path by a butt cap.

var RoundCap Capper = RoundCapper{}

RoundCap caps the start or end of a path by a round cap.

var SquareCap Capper = SquareCapper{}

SquareCap caps the start or end of a path by a square cap.

type Context Uses

type Context struct {
    Renderer

    Style
    // contains filtered or unexported fields
}

Context maintains the state for the current path, path style, and view transformation matrix.

func NewContext Uses

func NewContext(r Renderer) *Context

NewContext returns a new Context which is a wrapper around a Renderer. Context maintains state for the current path, path style, and view transformation matrix.

func (*Context) Arc Uses

func (c *Context) Arc(rx, ry, rot, theta0, theta1 float64)

Arc adds an elliptical arc with radii rx and ry, with rot the counter clockwise rotation in degrees, and theta0 and theta1 the angles in degrees of the ellipse (before rot is applies) between which the arc will run. If theta0 < theta1, the arc will run in a CCW direction. If the difference between theta0 and theta1 is bigger than 360 degrees, one full circle will be drawn and the remaining part of diff % 360 (eg. a difference of 810 degrees will draw one full circle and an arc over 90 degrees).

func (*Context) ArcTo Uses

func (c *Context) ArcTo(rx, ry, rot float64, large, sweep bool, x, y float64)

ArcTo adds an arc with radii rx and ry, with rot the counter clockwise rotation with respect to the coordinate system in degrees, large and sweep booleans (see https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Arcs), and x,y the end position of the pen. The start position of the pen was given by a previous command end point. When sweep is true it means following the arc in a CCW direction in the Cartesian coordinate system, ie. that is CW in the upper-left coordinate system as is the case in SVGs.

func (*Context) Close Uses

func (c *Context) Close()

Close closes the current path.

func (*Context) ComposeView Uses

func (c *Context) ComposeView(view Matrix)

ComposeView post-multiplies the current affine transformation matrix by the given one.

func (*Context) CubeTo Uses

func (c *Context) CubeTo(cpx1, cpy1, cpx2, cpy2, x, y float64)

CubeTo adds a cubic Bézier path with control points cpx1,cpy1 and cpx2,cpy2 and end point x,y.

func (*Context) DrawImage Uses

func (c *Context) DrawImage(x, y float64, img image.Image, dpm float64)

DrawImage draws an image at position (x,y), using an image encoding (Lossy or Lossless) and DPM (dots-per-millimeter). A higher DPM will draw a smaller image.

func (*Context) DrawPath Uses

func (c *Context) DrawPath(x, y float64, paths ...*Path)

DrawPath draws a path at position (x,y) using the current draw state.

func (*Context) DrawText Uses

func (c *Context) DrawText(x, y float64, texts ...*Text)

DrawText draws text at position (x,y) using the current draw state. In particular, it only uses the current affine transformation matrix.

func (*Context) Fill Uses

func (c *Context) Fill()

Fill fills the current path and resets it.

func (*Context) FillStroke Uses

func (c *Context) FillStroke()

FillStroke fills and then strokes the current path and resets it.

func (*Context) Height Uses

func (c *Context) Height() float64

Height returns the height of the canvas.

func (*Context) LineTo Uses

func (c *Context) LineTo(x, y float64)

LineTo adds a linear path to x,y.

func (*Context) MoveTo Uses

func (c *Context) MoveTo(x, y float64)

MoveTo moves the path to x,y without connecting the path. It starts a new independent subpath. Multiple subpaths can be useful when negating parts of a previous path by overlapping it with a path in the opposite direction. The behaviour for overlapping paths depend on the FillRule.

func (*Context) Pop Uses

func (c *Context) Pop()

Pop restores the last pushed draw state and uses that as the current draw state. If there are no states on the stack, this will do nothing.

func (*Context) Pos Uses

func (c *Context) Pos() (float64, float64)

Pos returns the current position of the path, which is the end point of the last command.

func (*Context) Push Uses

func (c *Context) Push()

Push saves the current draw state, so that it can be popped later on.

func (*Context) QuadTo Uses

func (c *Context) QuadTo(cpx, cpy, x, y float64)

QuadTo adds a quadratic Bézier path with control point cpx,cpy and end point x,y.

func (*Context) ReflectX Uses

func (c *Context) ReflectX()

ReflectX inverts the X axis of the view.

func (*Context) ReflectXAbout Uses

func (c *Context) ReflectXAbout(x float64)

ReflectXAbout inverts the X axis of the view.

func (*Context) ReflectY Uses

func (c *Context) ReflectY()

ReflectY inverts the Y axis of the view.

func (*Context) ReflectYAbout Uses

func (c *Context) ReflectYAbout(y float64)

ReflectYAbout inverts the Y axis of the view.

func (*Context) ResetStyle Uses

func (c *Context) ResetStyle()

ResetStyle resets the draw state to its default (colors, stroke widths, dashes, ...).

func (*Context) ResetView Uses

func (c *Context) ResetView()

ResetView resets the current affine transformation matrix to the Identity matrix, ie. no transformations.

func (*Context) Rotate Uses

func (c *Context) Rotate(rot float64)

Rotate rotates the view with rot in degrees.

func (*Context) RotateAbout Uses

func (c *Context) RotateAbout(rot, x, y float64)

RotateAbout rotates the view around (x,y) with rot in degrees.

func (*Context) Scale Uses

func (c *Context) Scale(sx, sy float64)

Scale scales the view.

func (*Context) ScaleAbout Uses

func (c *Context) ScaleAbout(sx, sy, x, y float64)

ScaleAbout scales the view around (x,y).

func (*Context) SetDashes Uses

func (c *Context) SetDashes(offset float64, dashes ...float64)

SetDashes sets the dash pattern to be used for stroking operations. The dash offset denotes the offset into the dash array in mm from where to start. Negative values are allowed.

func (*Context) SetFillColor Uses

func (c *Context) SetFillColor(col color.Color)

SetFillColor sets the color to be used for filling operations.

func (*Context) SetFillRule Uses

func (c *Context) SetFillRule(rule FillRule)

SetFillRule sets the fill rule to be used for filling paths.

func (*Context) SetStrokeCapper Uses

func (c *Context) SetStrokeCapper(capper Capper)

SetStrokeCapper sets the line cap function to be used for stroke endpoints.

func (*Context) SetStrokeColor Uses

func (c *Context) SetStrokeColor(col color.Color)

SetStrokeColor sets the color to be used for stroking operations.

func (*Context) SetStrokeJoiner Uses

func (c *Context) SetStrokeJoiner(joiner Joiner)

SetStrokeJoiner sets the line join function to be used for stroke midpoints.

func (*Context) SetStrokeWidth Uses

func (c *Context) SetStrokeWidth(width float64)

SetStrokeWidth sets the width in mm for stroking operations.

func (*Context) SetView Uses

func (c *Context) SetView(view Matrix)

SetView sets the current affine transformation matrix through which all operations will be transformed.

func (*Context) Shear Uses

func (c *Context) Shear(sx, sy float64)

Shear shear stretches the view.

func (*Context) ShearAbout Uses

func (c *Context) ShearAbout(sx, sy, x, y float64)

ShearAbout shear stretches the view around (x,y).

func (*Context) Stroke Uses

func (c *Context) Stroke()

Stroke strokes the current path and resets it.

func (*Context) Translate Uses

func (c *Context) Translate(x, y float64)

Translate moves the view.

func (*Context) View Uses

func (c *Context) View() Matrix

View returns the current affine transformation matrix.

func (*Context) Width Uses

func (c *Context) Width() float64

Width returns the width of the canvas.

type DPMM Uses

type DPMM float64

DPMM (Dots-per-Millimetter) for the resolution of raster images. Higher DPMM will result in bigger images.

type FillRule Uses

type FillRule int

FillRule is the algorithm to specify which area is to be filled and which not, in particular when multiple subpaths overlap. The NonZero rule is the default and will fill any point that is being enclosed by an unequal number of paths winding clockwise and counter clockwise, otherwise it will not be filled. The EvenOdd rule will fill any point that is being enclosed by an uneven number of path, whichever their direction.

const (
    NonZero FillRule = iota
    EvenOdd
)

see FillRule

type Font Uses

type Font struct {
    // contains filtered or unexported fields
}

Font defines a font of type TTF or OTF which which a FontFace can be generated for use in text drawing operations.

func (*Font) Bounds Uses

func (f *Font) Bounds(ppem float64) Rect

Bounds returns the union of a Font's glyphs' bounds.

func (*Font) IndicesOf Uses

func (f *Font) IndicesOf(s string) []uint16

func (*Font) ItalicAngle Uses

func (f *Font) ItalicAngle() float64

ItalicAngle in counter-clockwise degrees from the vertical. Zero for upright text, negative for text that leans to the right (forward).

func (*Font) Kerning Uses

func (f *Font) Kerning(left, right rune, ppem float64) (float64, error)

Kerning returns the horizontal adjustment for the rune pair. A positive kern means to move the glyphs further apart. Returns 0 if there is an error.

func (*Font) Metrics Uses

func (f *Font) Metrics(ppem float64) FontMetrics

Metrics returns the font metrics.

func (*Font) Name Uses

func (f *Font) Name() string

Name returns the name of the font.

func (*Font) Raw Uses

func (f *Font) Raw() (string, []byte)

Raw returns the mimetype and raw binary data of the font.

func (*Font) UnitsPerEm Uses

func (f *Font) UnitsPerEm() float64

UnitsPerEm returns the number of units per em for f.

func (*Font) Use Uses

func (f *Font) Use(options TypographicOptions)

Use enables typographic options on the font such as ligatures.

func (*Font) Widths Uses

func (f *Font) Widths(ppem float64) []float64

type FontDecorator Uses

type FontDecorator interface {
    Decorate(FontFace, float64) *Path
}

FontDecorator is an interface that returns a path given a font face and a width in mm.

var FontDashedUnderline FontDecorator = dashedUnderline{}

FontDashedUnderline is a font decoration that draws a dashed line at the base line.

var FontDottedUnderline FontDecorator = dottedUnderline{}

FontDottedUnderline is a font decoration that draws a dotted line at the base line.

var FontDoubleUnderline FontDecorator = doubleUnderline{}

FontDoubleUnderline is a font decoration that draws two lines at the base line.

var FontOverline FontDecorator = overline{}

FontOverline is a font decoration that draws a line over the text at the X-Height line.

var FontSawtoothUnderline FontDecorator = sawtoothUnderline{}

FontSawtoothUnderline is a font decoration that draws a wavy sawtooth path at the base line.

var FontSineUnderline FontDecorator = sineUnderline{}

FontSineUnderline is a font decoration that draws a wavy sine path at the base line.

var FontStrikethrough FontDecorator = strikethrough{}

FontStrikethrough is a font decoration that draws a line through the text in the middle between the base and X-Height line.

var FontUnderline FontDecorator = underline{}

FontUnderline is a font decoration that draws a line under the text at the base line.

type FontFace Uses

type FontFace struct {
    Font *Font

    Size    float64
    Style   FontStyle
    Variant FontVariant
    Color   color.RGBA

    Scale, Voffset, FauxBold, FauxItalic float64 // consequences of font style and variant
    // contains filtered or unexported fields
}

FontFace defines a font face from a given font. It allows setting the font size, its color, faux styles and font decorations.

func (FontFace) Boldness Uses

func (ff FontFace) Boldness() int

func (FontFace) Decorate Uses

func (ff FontFace) Decorate(width float64) *Path

Decorate will return a path from the decorations specified in the FontFace over a given width in mm.

func (FontFace) Equals Uses

func (ff FontFace) Equals(other FontFace) bool

Equals returns true when two font face are equal. In particular this allows two adjacent text spans that use the same decoration to allow the decoration to span both elements instead of two separately.

func (FontFace) Kerning Uses

func (ff FontFace) Kerning(rPrev, rNext rune) float64

Kerning returns the eventual kerning between two runes in mm (ie. the adjustment on the advance).

func (FontFace) Metrics Uses

func (ff FontFace) Metrics() FontMetrics

Metrics returns the font metrics. See https://developer.apple.com/library/archive/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png for an explanation of the different metrics.

func (FontFace) Name Uses

func (ff FontFace) Name() string

Name returns the name of the underlying font

func (FontFace) TextWidth Uses

func (ff FontFace) TextWidth(s string) float64

TextWidth returns the width of a given string in mm.

func (FontFace) ToPath Uses

func (ff FontFace) ToPath(s string) (*Path, float64)

ToPath converts a string to a path and also returns its advance in mm.

type FontFamily Uses

type FontFamily struct {
    // contains filtered or unexported fields
}

FontFamily contains a family of fonts (bold, italic, ...). Selecting an italic style will pick the native italic font or use faux italic if not present.

func NewFontFamily Uses

func NewFontFamily(name string) *FontFamily

NewFontFamily returns a new FontFamily.

func (*FontFamily) Face Uses

func (family *FontFamily) Face(size float64, col color.Color, style FontStyle, variant FontVariant, deco ...FontDecorator) FontFace

Face gets the font face given by the font size (in pt).

func (*FontFamily) LoadFont Uses

func (family *FontFamily) LoadFont(b []byte, style FontStyle) error

LoadFont loads a font from memory.

func (*FontFamily) LoadFontFile Uses

func (family *FontFamily) LoadFontFile(filename string, style FontStyle) error

LoadFontFile loads a font from a file.

func (*FontFamily) LoadLocalFont Uses

func (family *FontFamily) LoadLocalFont(name string, style FontStyle) error

LoadLocalFont loads a font from the system fonts location.

func (*FontFamily) Use Uses

func (family *FontFamily) Use(options TypographicOptions)

Use specifies which typographic options shall be used, ie. whether to use common typographic substitutions and which ligatures classes to use.

type FontMetrics Uses

type FontMetrics struct {
    LineHeight float64
    Ascent     float64
    Descent    float64
    XHeight    float64
    CapHeight  float64
}

FontMetrics contains a number of metrics that define a font face. See https://developer.apple.com/library/archive/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png for an explanation of the different metrics.

type FontStyle Uses

type FontStyle int

FontStyle defines the font style to be used for the font.

const (
    FontRegular    FontStyle = 0 // 400
    FontItalic     FontStyle = 1
    FontExtraLight FontStyle = 2 << iota // 100
    FontLight                            // 200
    FontBook                             // 300
    FontMedium                           // 500
    FontSemibold                         // 600
    FontBold                             // 700
    FontBlack                            // 800
    FontExtraBlack                       // 900
)

see FontStyle

type FontVariant Uses

type FontVariant int

FontVariant defines the font variant to be used for the font, such as subscript or smallcaps.

const (
    FontNormal FontVariant = 2 << iota
    FontSubscript
    FontSuperscript
    FontSmallcaps
)

see FontVariant

type GoChart Uses

type GoChart struct {
    // contains filtered or unexported fields
}

GoChart is a github.com/wcharczuk/go-chart renderer.

func (*GoChart) ArcTo Uses

func (r *GoChart) ArcTo(cx, cy int, rx, ry, startAngle, delta float64)

ArcTo draws an arc with a given center (cx,cy) a given set of radii (rx,ry), a startAngle and delta (in radians).

func (*GoChart) Circle Uses

func (r *GoChart) Circle(radius float64, x, y int)

Circle draws a circle at the given coords with a given radius.

func (*GoChart) ClearTextRotation Uses

func (r *GoChart) ClearTextRotation()

ClearTextRotation clears rotation.

func (*GoChart) Close Uses

func (r *GoChart) Close()

Close finalizes a shape as drawn by LineTo.

func (*GoChart) Fill Uses

func (r *GoChart) Fill()

Fill fills the path, but does not stroke.

func (*GoChart) FillStroke Uses

func (r *GoChart) FillStroke()

FillStroke fills and strokes a path.

func (*GoChart) GetDPI Uses

func (r *GoChart) GetDPI() float64

GetDPI gets the DPI for the renderer.

func (*GoChart) LineTo Uses

func (r *GoChart) LineTo(x, y int)

LineTo both starts a shape and draws a line to a given point from the previous point.

func (*GoChart) MeasureText Uses

func (r *GoChart) MeasureText(body string) chart.Box

MeasureText measures text.

func (*GoChart) MoveTo Uses

func (r *GoChart) MoveTo(x, y int)

MoveTo moves the cursor to a given point.

func (*GoChart) QuadCurveTo Uses

func (r *GoChart) QuadCurveTo(cx, cy, x, y int)

QuadCurveTo draws a quad curve. cx and cy represent the bezier "control points".

func (*GoChart) ResetStyle Uses

func (r *GoChart) ResetStyle()

ResetStyle should reset any style related settings on the renderer.

func (*GoChart) Save Uses

func (r *GoChart) Save(w io.Writer) error

Save writes the image to the given writer.

func (*GoChart) SetClassName Uses

func (r *GoChart) SetClassName(name string)

SetClassName sets the current class name.

func (*GoChart) SetDPI Uses

func (r *GoChart) SetDPI(dpi float64)

SetDPI sets the DPI for the renderer.

func (*GoChart) SetFillColor Uses

func (r *GoChart) SetFillColor(col drawing.Color)

SetFillColor sets the current fill color.

func (*GoChart) SetFont Uses

func (r *GoChart) SetFont(font *truetype.Font)

SetFont sets a font for a text field.

func (*GoChart) SetFontColor Uses

func (r *GoChart) SetFontColor(col drawing.Color)

SetFontColor sets a font's color

func (*GoChart) SetFontSize Uses

func (r *GoChart) SetFontSize(size float64)

SetFontSize sets the font size for a text field.

func (*GoChart) SetStrokeColor Uses

func (r *GoChart) SetStrokeColor(col drawing.Color)

SetStrokeColor sets the current stroke color.

func (*GoChart) SetStrokeDashArray Uses

func (r *GoChart) SetStrokeDashArray(dashArray []float64)

SetStrokeDashArray sets the stroke dash array.

func (*GoChart) SetStrokeWidth Uses

func (r *GoChart) SetStrokeWidth(width float64)

SetStrokeWidth sets the stroke width.

func (*GoChart) SetTextRotation Uses

func (r *GoChart) SetTextRotation(radian float64)

SetTextRotation sets a rotation for drawing elements.

func (*GoChart) Stroke Uses

func (r *GoChart) Stroke()

Stroke strokes the path.

func (*GoChart) Text Uses

func (r *GoChart) Text(body string, x, y int)

Text draws a text blob.

type GonumPlot Uses

type GonumPlot struct {
    // contains filtered or unexported fields
}

GonumPlot is a github.com/gonum/plot/vg renderer.

func (*GonumPlot) DrawImage Uses

func (r *GonumPlot) DrawImage(rect vg.Rectangle, img image.Image)

DrawImage draws the image, scaled to fit the destination rectangle.

func (*GonumPlot) Fill Uses

func (r *GonumPlot) Fill(path vg.Path)

Fill fills the given path.

func (*GonumPlot) FillString Uses

func (r *GonumPlot) FillString(f vg.Font, pt vg.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.

func (*GonumPlot) Pop Uses

func (r *GonumPlot) Pop()

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

func (*GonumPlot) Push Uses

func (r *GonumPlot) 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().

func (*GonumPlot) Rotate Uses

func (r *GonumPlot) Rotate(rad float64)

Rotate applies a rotation transform to the context. The parameter is specified in radians.

func (*GonumPlot) Scale Uses

func (r *GonumPlot) Scale(x, y float64)

Scale applies a scaling transform to the context

func (*GonumPlot) SetColor Uses

func (r *GonumPlot) SetColor(col 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.

func (*GonumPlot) SetLineDash Uses

func (r *GonumPlot) SetLineDash(pattern []vg.Length, offset vg.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.

func (*GonumPlot) SetLineWidth Uses

func (r *GonumPlot) SetLineWidth(length vg.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.

func (*GonumPlot) Size Uses

func (r *GonumPlot) Size() (vg.Length, vg.Length)

Size returns the width and height of a Rectangle.

func (*GonumPlot) Stroke Uses

func (r *GonumPlot) Stroke(path vg.Path)

Stroke strokes the given path.

func (*GonumPlot) Translate Uses

func (r *GonumPlot) Translate(pt vg.Point)

Translate applies a translational transform to the context.

type ImageEncoding Uses

type ImageEncoding int

ImageEncoding defines whether the embedded image shall be embedded as Lossless (typically PNG) or Lossy (typically JPG).

const (
    Lossless ImageEncoding = iota
    Lossy
)

see ImageEncoding

type Joiner Uses

type Joiner interface {
    Join(*Path, *Path, float64, Point, Point, Point, float64, float64)
}

Joiner implements Join, with rhs the right path and lhs the left path to append to, pivot the intersection of both path elements, n0 and n1 the normals at the start and end of the path respectively. The length of n0 and n1 are equal to the halfWidth.

var ArcsJoin Joiner = ArcsJoiner{BevelJoin, 10.0}

ArcsJoin connects two path elements by extending the ends of the paths as circle arcs until they meet. If this point is further than 10 mm * (strokeWidth / 2.0) away, this will result in a bevel join.

var BevelJoin Joiner = BevelJoiner{}

BevelJoin connects two path elements by a linear join.

var MiterJoin Joiner = MiterJoiner{BevelJoin, 2.0}

MiterJoin connects two path elements by extending the ends of the paths as lines until they meet. If this point is further than 2 mm * (strokeWidth / 2.0) away, this will result in a bevel join.

var RoundJoin Joiner = RoundJoiner{}

RoundJoin connects two path elements by a round join.

func ArcsClipJoin Uses

func ArcsClipJoin(gapJoiner Joiner, limit float64) Joiner

ArcsClipJoin returns an ArcsJoiner with given limit in mm*strokeWidth/2.0 upon which the gapJoiner function will be used. Limit can be NaN so that the gapJoiner is never used.

func MiterClipJoin Uses

func MiterClipJoin(gapJoiner Joiner, limit float64) Joiner

MiterClipJoin returns a MiterJoiner with given limit*strokeWidth/2.0 in mm upon which the gapJoiner function will be used. Limit can be NaN so that the gapJoiner is never used.

type Matrix Uses

type Matrix [2][3]float64

Matrix is used for affine transformations. Be aware that concatenating transformation function will be evaluated right-to-left! So that Identity.Rotate(30).Translate(20,0) will first translate 20 points horizontally and then rotate 30 degrees counter clockwise.

func (Matrix) Decompose Uses

func (m Matrix) Decompose() (float64, float64, float64, float64, float64, float64)

Decompose extracts the translation, rotation, scaling and rotation components (applied in the reverse order) as (tx, ty, theta, sx, sy, phi) with rotation counter clockwise. This corresponds to Identity.Translate(tx, ty).Rotate(theta).Scale(sx, sy).Rotate(phi).

func (Matrix) Det Uses

func (m Matrix) Det() float64

Det returns the matrix determinant.

func (Matrix) Dot Uses

func (m Matrix) Dot(p Point) Point

Dot returns the dot product between the matrix and the given vector (ie. apply transformation).

func (Matrix) Eigen Uses

func (m Matrix) Eigen() (float64, float64, Point, Point)

Eigen returns the matrix eigenvalues and eigenvectors. The first eigenvalue is related to the first eigenvector, and so for the second pair. Eigenvectors are normalized.

func (Matrix) Equals Uses

func (m Matrix) Equals(q Matrix) bool

Equals returns true if both matrices are equal with a tolerance of Epsilon.

func (Matrix) Inv Uses

func (m Matrix) Inv() Matrix

Inv returns the matrix inverse.

func (Matrix) IsRigid Uses

func (m Matrix) IsRigid() bool

IsRigid is true if the matrix consists of only (proper) rigid transformations, ie. no scaling or skew.

func (Matrix) IsTranslation Uses

func (m Matrix) IsTranslation() bool

IsTranslation is true if the matrix consists of only translational components, ie. no rotation, scaling or skew.

func (Matrix) Mul Uses

func (m Matrix) Mul(q Matrix) Matrix

Mul multiplies the current matrix by the given matrix (ie. combine transformations).

func (Matrix) Pos Uses

func (m Matrix) Pos() (float64, float64)

Pos extracts the translation component as (tx, ty).

func (Matrix) ReflectX Uses

func (m Matrix) ReflectX() Matrix

ReflectX adds a horizontal reflection transformation (ie. Scale(-1,1)).

func (Matrix) ReflectXAbout Uses

func (m Matrix) ReflectXAbout(x float64) Matrix

ReflectXAbout adds a horizontal reflection transformation around position x.

func (Matrix) ReflectY Uses

func (m Matrix) ReflectY() Matrix

ReflectY adds a vertical reflection transformation (ie. Scale(1,-1)).

func (Matrix) ReflectYAbout Uses

func (m Matrix) ReflectYAbout(y float64) Matrix

ReflectYAbout adds a vertical reflection transformation around position y.

func (Matrix) Rotate Uses

func (m Matrix) Rotate(rot float64) Matrix

Rotate adds a rotation transformation with rot in degree counter clockwise.

func (Matrix) RotateAbout Uses

func (m Matrix) RotateAbout(rot, x, y float64) Matrix

RotateAbout adds a rotation transformation around point (x,y) with rot in degrees counter clockwise.

func (Matrix) Scale Uses

func (m Matrix) Scale(sx, sy float64) Matrix

Scale adds a scaling transformation in sx and sy. When scale is negative it will flip those axes.

func (Matrix) ScaleAbout Uses

func (m Matrix) ScaleAbout(sx, sy, x, y float64) Matrix

ScaleAbout adds a scaling transformation around point (x,y) in sx and sy. When scale is negative it will flip those axes.

func (Matrix) Shear Uses

func (m Matrix) Shear(sx, sy float64) Matrix

Shear adds a shear transformation with sx the horizontal shear and sy the vertical shear.

func (Matrix) ShearAbout Uses

func (m Matrix) ShearAbout(sx, sy, x, y float64) Matrix

ShearAbout adds a shear transformation around point (x,y) with sx the horizontal shear and sy the vertical shear.

func (Matrix) String Uses

func (m Matrix) String() string

String returns a string representation of the affine transformation matrix as six values, where [a b c; d e f; g h i] will be written as "a b d e c f" as g, h and i have fixed values (0, 0 and 1 respectively).

func (Matrix) T Uses

func (m Matrix) T() Matrix

T returns the matrix transpose.

func (Matrix) ToSVG Uses

func (m Matrix) ToSVG(h float64) string

ToSVG writes out the matrix in SVG notation, taking care of the proper order of transformations.

func (Matrix) Translate Uses

func (m Matrix) Translate(x, y float64) Matrix

Translate adds a translation in x and y.

type MiterJoiner Uses

type MiterJoiner struct {
    GapJoiner Joiner
    Limit     float64
}

MiterJoiner is a miter joiner.

func (MiterJoiner) Join Uses

func (j MiterJoiner) Join(rhs, lhs *Path, halfWidth float64, pivot, n0, n1 Point, r0, r1 float64)

Join adds a join to a right-hand-side and left-hand-side path, of width 2*halfWidth, around a pivot point with starting and ending normals of n0 and n1, and radius of curvatures of the previous and next segments.

func (MiterJoiner) String Uses

func (j MiterJoiner) String() string

type Path Uses

type Path struct {
    // contains filtered or unexported fields
}

Path defines a vector path in 2D using a series of connected commands (MoveTo, LineTo, QuadTo, CubeTo, ArcTo and Close). Each command consists of a number of float64 values (depending on the command) that fully define the action. The first value is the command itself (as a float64). The last two values are the end point position of the pen after the action (x,y). QuadTo defined one control point (x,y) in between, CubeTo defines two control points, and ArcTo defines (rx,ry,phi,large+sweep) i.e. the radius in x and y, its rotation (in radians) and the large and sweep booleans in one float64. Only valid commands are appended, so that LineTo has a non-zero length, QuadTo's and CubeTo's control point(s) don't (both) overlap with the start and end point, and ArcTo has non-zero radii and has non-zero length. For ArcTo we also make sure the angle is is in the range [0, 2*PI) and we scale the radii up if they appear too small to fit the arc.

func BeveledRectangle Uses

func BeveledRectangle(w, h, r float64) *Path

BeveledRectangle returns a rectangle with width w and height h with beveled corners at distance r from the corner.

func Circle Uses

func Circle(r float64) *Path

Circle returns a circle with radius r.

func Ellipse Uses

func Ellipse(rx, ry float64) *Path

Ellipse returns an ellipse with radii rx,ry.

func MustParseSVG Uses

func MustParseSVG(s string) *Path

MustParseSVG parses an SVG path data string and panics if it fails.

func ParseLaTeX Uses

func ParseLaTeX(s string) (*Path, error)

ParseLaTeX parses a LaTeX formatted string into a path. It requires latex and dvisvgm to be installed on the machine. The content is surrounded by

\documentclass{article}
\begin{document}
\thispagestyle{empty}
{{input}}
\end{document}

func ParseSVG Uses

func ParseSVG(s string) (*Path, error)

ParseSVG parses an SVG path data string.

func Rectangle Uses

func Rectangle(w, h float64) *Path

Rectangle returns a rectangle with width w and height h.

func RegularPolygon Uses

func RegularPolygon(n int, r float64, up bool) *Path

RegularPolygon returns a regular polygon with radius r and rotation rot in degrees. It uses n vertices/edges, so when n approaches infinity this will return a path that approximates a circle. n must be 3 or more. The up boolean defines whether the first point will point north or not.

func RegularStarPolygon Uses

func RegularStarPolygon(n, d int, r float64, up bool) *Path

RegularStarPolygon returns a regular star polygon with radius r and rotation rot in degrees. It uses n vertices of density d. This will result in a self-intersection star in counter clockwise direction. If n/2 < d the star will be clockwise and if n and d are not coprime a regular polygon will be obtained, possible with multiple windings. n must be 3 or more and d 2 or more. The up boolean defines whether the first point will point north or not.

func RoundedRectangle Uses

func RoundedRectangle(w, h, r float64) *Path

RoundedRectangle returns a rectangle with width w and height h with rounded corners of radius r. A negative radius will cast the corners inwards (ie. concave).

func StarPolygon Uses

func StarPolygon(n int, R, r float64, up bool) *Path

StarPolygon returns a star polygon of n points with alternating radius R and r. The up boolean defines whether the first point (true) or second point (false) will be pointing north.

func (*Path) Append Uses

func (p *Path) Append(q *Path) *Path

Append appends path q to p and returns a new path if succesful (otherwise either p or q are returned).

func (*Path) Arc Uses

func (p *Path) Arc(rx, ry, rot, theta0, theta1 float64) *Path

Arc adds an elliptical arc with radii rx and ry, with rot the counter clockwise rotation in degrees, and theta0 and theta1 the angles in degrees of the ellipse (before rot is applies) between which the arc will run. If theta0 < theta1, the arc will run in a CCW direction. If the difference between theta0 and theta1 is bigger than 360 degrees, one full circle will be drawn and the remaining part of diff % 360 (eg. a difference of 810 degrees will draw one full circle and an arc over 90 degrees).

func (*Path) ArcTo Uses

func (p *Path) ArcTo(rx, ry, rot float64, large, sweep bool, x, y float64) *Path

ArcTo adds an arc with radii rx and ry, with rot the counter clockwise rotation with respect to the coordinate system in degrees, large and sweep booleans (see https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#Arcs), and x,y the end position of the pen. The start position of the pen was given by a previous command end point. When sweep is true it means following the arc in a CCW direction in the Cartesian coordinate system, ie. that is CW in the upper-left coordinate system as is the case in SVGs.

func (*Path) Bounds Uses

func (p *Path) Bounds() Rect

Bounds returns the bounding box rectangle of the path.

func (*Path) CCW Uses

func (p *Path) CCW() bool

CCW returns true when the path has (mostly) a counter clockwise direction. Does not need the path to be closed and will return true for a empty or straight line.

func (*Path) Close Uses

func (p *Path) Close() *Path

Close closes a (sub)path with a LineTo to the start of the path (the most recent MoveTo command). It also signals the path closes as opposed to being just a LineTo command, which can be significant for stroking purposes for example.

func (*Path) Closed Uses

func (p *Path) Closed() bool

Closed returns true if the last subpath of p is a closed path.

func (*Path) Coords Uses

func (p *Path) Coords() []Point

Coords returns all the coordinates of the segment start/end points.

func (*Path) Copy Uses

func (p *Path) Copy() *Path

Copy returns a copy of p.

func (*Path) CubeTo Uses

func (p *Path) CubeTo(cpx1, cpy1, cpx2, cpy2, x, y float64) *Path

CubeTo adds a cubic Bézier path with control points cpx1,cpy1 and cpx2,cpy2 and end point x,y.

func (*Path) Dash Uses

func (p *Path) Dash(offset float64, d ...float64) *Path

Dash returns a new path that consists of dashes. The elements in d specify the width of the dashes and gaps. It will alternate between dashes and gaps when picking widths. If d is an array of odd length, it is equivalent of passing d twice in sequence. The offset specifies the offset used into d (or negative offset onto the path). Dash will be applied to each subpath independently.

func (*Path) Empty Uses

func (p *Path) Empty() bool

Empty returns true if p is an empty path or consists of only MoveTos and Closes.

func (*Path) Equals Uses

func (p *Path) Equals(q *Path) bool

Equals returns true if p and q are equal within tolerance Epsilon.

func (*Path) Filling Uses

func (p *Path) Filling(fillRule FillRule) []bool

Filling returns whether each subpath gets filled or not. A path may not be filling when it negates another path and depends on the FillRule. If a subpath is not closed, it is implicitly assumed to be closed. If the path has no area it will return false.

func (*Path) Flatten Uses

func (p *Path) Flatten() *Path

Flatten flattens all Bézier and arc curves into linear segments and returns a new path. It uses Tolerance as the maximum deviation.

func (*Path) Interior Uses

func (p *Path) Interior(x, y float64, fillRule FillRule) bool

Interior is true when the point (x,y) is in the interior of the path, ie. gets filled. This depends on the FillRule.

func (*Path) Iterate Uses

func (p *Path) Iterate(
    move func(Point, Point),
    line func(Point, Point),
    quad func(Point, Point, Point),
    cube func(Point, Point, Point, Point),
    arc func(Point, float64, float64, float64, bool, bool, Point),
    close func(Point, Point),
)

Iterate iterates oves the path commands and calls the respective functions move, line, quad, cube, arc, close when encountering a MoveTo, LineTo, QuadTo, CubeTo, ArcTo, Close command.

func (*Path) Join Uses

func (p *Path) Join(q *Path) *Path

Join joins path q to p and returns a new path if succesful (otherwise either p or q are returned). Its like executing the commands in q to p in sequence, where if the first MoveTo of q doesn't coincide with p it will fallback to appending the paths.

func (*Path) Length Uses

func (p *Path) Length() float64

Length returns the length of the path in millimeters. The length is approximated for cubic Béziers.

func (*Path) LineTo Uses

func (p *Path) LineTo(x, y float64) *Path

LineTo adds a linear path to x,y.

func (*Path) Markers Uses

func (p *Path) Markers(first, mid, last *Path, align bool) []*Path

Markers returns an array of start, mid and end markers along the path at the path coordinates between commands. Align will align the markers with the path direction so that the markers orient towards the path's left.

func (*Path) MoveTo Uses

func (p *Path) MoveTo(x, y float64) *Path

MoveTo moves the path to x,y without connecting the path. It starts a new independent subpath. Multiple subpaths can be useful when negating parts of a previous path by overlapping it with a path in the opposite direction. The behaviour for overlapping paths depend on the FillRule.

func (*Path) Offset Uses

func (p *Path) Offset(w float64, fillRule FillRule) *Path

Offset offsets the path to expand by w and returns a new path. If w is negative it will contract. Path must be closed.

func (*Path) Pos Uses

func (p *Path) Pos() Point

Pos returns the current position of the path, which is the end point of the last command.

func (*Path) QuadTo Uses

func (p *Path) QuadTo(cpx, cpy, x, y float64) *Path

QuadTo adds a quadratic Bézier path with control point cpx,cpy and end point x,y.

func (*Path) ReplaceArcs Uses

func (p *Path) ReplaceArcs() *Path

ReplaceArcs replaces ArcTo commands by CubeTo commands.

func (*Path) Reverse Uses

func (p *Path) Reverse() *Path

Reverse returns a new path that is the same path as p but in the reverse direction.

func (*Path) Split Uses

func (p *Path) Split() []*Path

Split splits the path into its independent subpaths. The path is split before each MoveTo command. None of the subpaths shall be empty.

func (*Path) SplitAt Uses

func (p *Path) SplitAt(ts ...float64) []*Path

SplitAt splits the path into separate paths at the specified intervals (given in millimeters) along the path.

func (*Path) StartPos Uses

func (p *Path) StartPos() Point

StartPos returns the start point of the current subpath, ie. it returns the position of the last MoveTo command.

func (*Path) String Uses

func (p *Path) String() string

String returns a string that represents the path similar to the SVG path data format (but not necessarily valid SVG).

func (*Path) Stroke Uses

func (p *Path) Stroke(w float64, cr Capper, jr Joiner) *Path

Stroke converts a path into a stroke of width w and returns a new path. It uses cr to cap the start and end of the path, and jr to join all path elemtents. If the path closes itself, it will use a join between the start and end instead of capping them. The tolerance is the maximum deviation from the original path when flattening Béziers and optimizing the stroke.

func (*Path) Tessellate Uses

func (p *Path) Tessellate() ([][3]Point, [][5]Point)

Tessellate tessellates the path and returns the triangles that fill the path. WIP

func (*Path) ToPDF Uses

func (p *Path) ToPDF() string

ToPDF returns a string that represents the path in the PDF data format.

func (*Path) ToPS Uses

func (p *Path) ToPS() string

ToPS returns a string that represents the path in the PostScript data format.

func (*Path) ToRasterizer Uses

func (p *Path) ToRasterizer(ras *vector.Rasterizer, dpm float64)

ToRasterizer rasterizes the path using the given rasterizer with dpm the dots-per-millimeter.

func (*Path) ToSVG Uses

func (p *Path) ToSVG() string

ToSVG returns a string that represents the path in the SVG path data format with minifications.

func (*Path) Transform Uses

func (p *Path) Transform(m Matrix) *Path

Transform transform the path by the given transformation matrix and returns a new path.

func (*Path) Translate Uses

func (p *Path) Translate(x, y float64) *Path

Translate translates the path by (x,y) and returns a new path.

type Point Uses

type Point struct {
    X, Y float64
}

Point is a coordinate in 2D space. OP refers to the line that goes through the origin (0,0) and this point (x,y).

func (Point) Add Uses

func (p Point) Add(q Point) Point

Add adds Q to P.

func (Point) Angle Uses

func (p Point) Angle() float64

Angle returns the angle in radians between the x-axis and OP.

func (Point) AngleBetween Uses

func (p Point) AngleBetween(q Point) float64

AngleBetween returns the angle between OP and OQ.

func (Point) Div Uses

func (p Point) Div(f float64) Point

Div divides x and y by f.

func (Point) Dot Uses

func (p Point) Dot(q Point) float64

Dot returns the dot product between OP and OQ, ie. zero if perpendicular and |OP|*|OQ| if aligned.

func (Point) Equals Uses

func (p Point) Equals(q Point) bool

Equals returns true if P and Q are equal with tolerance Epsilon.

func (Point) Interpolate Uses

func (p Point) Interpolate(q Point, t float64) Point

Interpolate returns a point on PQ that is linearly interpolated by t in [0,1], ie. t=0 returns P and t=1 returns Q.

func (Point) IsZero Uses

func (p Point) IsZero() bool

IsZero returns true if P is exactly zero.

func (Point) Length Uses

func (p Point) Length() float64

Length returns the length of OP.

func (Point) Mul Uses

func (p Point) Mul(f float64) Point

Mul multiplies x and y by f.

func (Point) Neg Uses

func (p Point) Neg() Point

Neg negates x and y.

func (Point) Norm Uses

func (p Point) Norm(length float64) Point

Norm normalized OP to be of given length.

func (Point) PerpDot Uses

func (p Point) PerpDot(q Point) float64

PerpDot returns the perp dot product between OP and OQ, ie. zero if aligned and |OP|*|OQ| if perpendicular.

func (Point) Rot Uses

func (p Point) Rot(phi float64, p0 Point) Point

Rot rotates the line OP by phi radians CCW.

func (Point) Rot90CCW Uses

func (p Point) Rot90CCW() Point

Rot90CCW rotates the line OP by 90 degrees CCW.

func (Point) Rot90CW Uses

func (p Point) Rot90CW() Point

Rot90CW rotates the line OP by 90 degrees CW.

func (Point) Slope Uses

func (p Point) Slope() float64

Slope returns the slope between OP, ie. y/x.

func (Point) String Uses

func (p Point) String() string

String returns the string representation of a point, such as "(x,y)".

func (Point) Sub Uses

func (p Point) Sub(q Point) Point

Sub subtracts Q from P.

type Polyline Uses

type Polyline struct {
    // contains filtered or unexported fields
}

Polyline defines a list of points in 2D space that form a polyline. If the last coordinate equals the first coordinate, we assume the polyline to close itself.

func PolylineFromPath Uses

func PolylineFromPath(p *Path) *Polyline

PolylineFromPath returns a polyline from the given path by approximating it by linear line segments (ie. flattening).

func PolylineFromPathCoords Uses

func PolylineFromPathCoords(p *Path) *Polyline

PolylineFromPathCoords returns a polyline from the given path from each of the start/end coordinates of the segments, ie. converting all non-linear segments to linear ones.

func (*Polyline) Add Uses

func (p *Polyline) Add(x, y float64) *Polyline

Add adds a new point to the polyline.

func (*Polyline) Coords Uses

func (p *Polyline) Coords() []Point

Coords returns the list of coordinates of the polyline.

func (*Polyline) FillCount Uses

func (p *Polyline) FillCount(x, y float64) int

FillCount returns the number of times the test point is enclosed by the polyline. Counter clockwise enclosures are counted positively and clockwise enclosures negatively.

func (*Polyline) Interior Uses

func (p *Polyline) Interior(x, y float64, fillRule FillRule) bool

Interior is true when the point (x,y) is in the interior of the path, ie. gets filled. This depends on the FillRule.

func (*Polyline) Smoothen Uses

func (p *Polyline) Smoothen() *Path

Smoothen returns a new path that smoothens out a path using cubic Béziers between all the path points. It makes sure that the curvature is smooth along the whole path. If the path is closed, it will be smooth between start and end segment too.

func (*Polyline) ToPath Uses

func (p *Polyline) ToPath() *Path

ToPath convertes the polyline to a path. If the last coordinate equals the first one, we close the path.

type Rect Uses

type Rect struct {
    X, Y, W, H float64
}

Rect is a rectangle in 2D defined by a position and its width and height.

func (Rect) Add Uses

func (r Rect) Add(q Rect) Rect

Add returns a rect that encompasses both the current rect and the given rect.

func (Rect) Equals Uses

func (r Rect) Equals(q Rect) bool

Equals returns true if rectangles are equal with tolerance Epsilon.

func (Rect) Move Uses

func (r Rect) Move(p Point) Rect

Move translates the rect.

func (Rect) String Uses

func (r Rect) String() string

String returns a string representation of r such as "(xmin,ymin)-(xmax,ymax)".

func (Rect) ToPath Uses

func (r Rect) ToPath() *Path

ToPath converts the rectangle to a *Path.

func (Rect) Transform Uses

func (r Rect) Transform(m Matrix) Rect

Transform transforms the rectangle by affine transformation matrix m and returns the new bounds of that rectangle.

type Renderer Uses

type Renderer interface {
    Size() (float64, float64)
    RenderPath(path *Path, style Style, m Matrix)
    RenderText(text *Text, m Matrix)
    RenderImage(img image.Image, m Matrix)
}

Renderer is an interface that renderers implement. It defines the size of the target (in mm) and functions to render paths, text objects and raster images.

type RichText Uses

type RichText struct {
    // contains filtered or unexported fields
}

RichText allows to build up a rich text with text spans of different font faces and by fitting that into a box.

func NewRichText Uses

func NewRichText() *RichText

NewRichText returns a new RichText.

func (*RichText) Add Uses

func (rt *RichText) Add(ff FontFace, s string) *RichText

Add adds a new text span element.

func (*RichText) ToText Uses

func (rt *RichText) ToText(width, height float64, halign, valign TextAlign, indent, lineStretch float64) *Text

ToText takes the added text spans and fits them within a given box of certain width and height.

type RoundCapper Uses

type RoundCapper struct{}

RoundCapper is a round capper.

func (RoundCapper) Cap Uses

func (RoundCapper) Cap(p *Path, halfWidth float64, pivot, n0 Point)

Cap adds a cap to path p of width 2*halfWidth, at a pivot point and initial normal direction of n0.

func (RoundCapper) String Uses

func (RoundCapper) String() string

type RoundJoiner Uses

type RoundJoiner struct{}

RoundJoiner is a round joiner.

func (RoundJoiner) Join Uses

func (RoundJoiner) Join(rhs, lhs *Path, halfWidth float64, pivot, n0, n1 Point, r0, r1 float64)

Join adds a join to a right-hand-side and left-hand-side path, of width 2*halfWidth, around a pivot point with starting and ending normals of n0 and n1, and radius of curvatures of the previous and next segments.

func (RoundJoiner) String Uses

func (RoundJoiner) String() string

type SquareCapper Uses

type SquareCapper struct{}

SquareCapper is a square capper.

func (SquareCapper) Cap Uses

func (SquareCapper) Cap(p *Path, halfWidth float64, pivot, n0 Point)

Cap adds a cap to path p of width 2*halfWidth, at a pivot point and initial normal direction of n0.

func (SquareCapper) String Uses

func (SquareCapper) String() string

type Style Uses

type Style struct {
    FillColor    color.RGBA
    StrokeColor  color.RGBA
    StrokeWidth  float64
    StrokeCapper Capper
    StrokeJoiner Joiner
    DashOffset   float64
    Dashes       []float64
    FillRule
}

Style is the path style that defines how to draw the path. When FillColor is transparent it will not fill the path. If StrokeColor is transparent or StrokeWidth is zero, it will not stroke the path. If Dashes is an empty array, it will not draw dashes but instead a solid stroke line. FillRule determines how to fill the path when paths overlap and have certain directions (clockwise, counter clockwise).

type TeX Uses

type TeX struct {
    // contains filtered or unexported fields
}

func NewTeX Uses

func NewTeX(w io.Writer, width, height float64) *TeX

NewTeX creates a TeX/pgf renderer.

func (*TeX) Close Uses

func (r *TeX) Close() error

func (*TeX) RenderImage Uses

func (r *TeX) RenderImage(img image.Image, m Matrix)

func (*TeX) RenderPath Uses

func (r *TeX) RenderPath(path *Path, style Style, m Matrix)

func (*TeX) RenderText Uses

func (r *TeX) RenderText(text *Text, m Matrix)

func (*TeX) Size Uses

func (r *TeX) Size() (float64, float64)

type Text Uses

type Text struct {
    // contains filtered or unexported fields
}

Text holds the representation of text using lines and text spans.

func NewTextBox Uses

func NewTextBox(ff FontFace, s string, width, height float64, halign, valign TextAlign, indent, lineStretch float64) *Text

NewTextBox is an advanced text formatter that will calculate text placement based on the setteings. It takes a font face, a string, the width or height of the box (can be zero for no limit), horizontal and vertical alignment (Left, Center, Right, Top, Bottom or Justify), text indentation for the first line and line stretch (percentage to stretch the line based on the line height).

func NewTextLine Uses

func NewTextLine(ff FontFace, s string, halign TextAlign) *Text

NewTextLine is a simple text line using a font face, a string (supporting new lines) and horizontal alignment (Left, Center, Right).

func (*Text) Bounds Uses

func (t *Text) Bounds() Rect

Bounds returns the bounding rectangle that defines the text box.

func (*Text) Empty Uses

func (t *Text) Empty() bool

Empty is true if there are no text lines or no text spans.

func (*Text) Fonts Uses

func (t *Text) Fonts() []*Font

Fonts returns list of fonts used.

func (*Text) Height Uses

func (t *Text) Height() float64

Height returns the height of the text using the font metrics, this is usually more than the bounds of the glyph outlines.

func (*Text) MostCommonFontFace Uses

func (t *Text) MostCommonFontFace() FontFace

MostCommonFontFace returns the most common FontFace of the text

func (*Text) OutlineBounds Uses

func (t *Text) OutlineBounds() Rect

OutlineBounds returns the rectangle that contains the entire text box, ie. the glyph outlines (slow).

func (*Text) RenderDecoration Uses

func (t *Text) RenderDecoration(r Renderer, m Matrix)

RenderDecoration renders the text decorations using the RenderPath method of the Renderer. TODO: check text decoration z-positions when text lines are overlapping https://github.com/tdewolff/canvas/pull/40#pullrequestreview-400951503 TODO: check compliance with https://drafts.csswg.org/css-text-decor-4/#text-line-constancy

func (*Text) ToPaths Uses

func (t *Text) ToPaths() ([]*Path, []color.RGBA)

ToPaths makes a path out of the text, with x,y the top-left point of the rectangle that fits the text (ie. y is not the text base)

func (*Text) WalkSpans Uses

func (t *Text) WalkSpans(cb func(y, dx float64, span TextSpan))

type TextAlign Uses

type TextAlign int

TextAlign specifies how the text should align or whether it should be justified.

const (
    Left TextAlign = iota
    Right
    Center
    Top
    Bottom
    Justify
)

see TextAlign

type TextSpan Uses

type TextSpan struct {
    Face FontFace
    Text string

    SentenceSpacing float64
    WordSpacing     float64
    GlyphSpacing    float64
    // contains filtered or unexported fields
}

func (TextSpan) Bounds Uses

func (span TextSpan) Bounds(width float64) Rect

func (TextSpan) CountGlyphs Uses

func (span TextSpan) CountGlyphs() int

CountGlyphs counts all the glyphs, where ligatures are separated into their constituent parts

func (TextSpan) ReplaceLigatures Uses

func (span TextSpan) ReplaceLigatures() TextSpan

ReplaceLigatures replaces all ligatures by their constituent parts

func (TextSpan) Split Uses

func (span TextSpan) Split(width float64) ([]TextSpan, bool)

func (TextSpan) ToPath Uses

func (span TextSpan) ToPath(width float64) (*Path, *Path, color.RGBA)

TODO: transform to Draw to canvas and cache the glyph rasterizations? TODO: remove width argument and use span.width?

func (TextSpan) TrimLeft Uses

func (span TextSpan) TrimLeft() TextSpan

func (TextSpan) TrimRight Uses

func (span TextSpan) TrimRight() TextSpan

func (TextSpan) Words Uses

func (span TextSpan) Words() []string

Words returns the text of the span, split on wordBoundaries

type TypographicOptions Uses

type TypographicOptions int

TypographicOptions are the options that can be enabled to make typographic or ligature substitutions automatically.

const (
    NoTypography TypographicOptions = 2 << iota
    NoRequiredLigatures
    CommonLigatures
    DiscretionaryLigatures
    HistoricalLigatures
)

see TypographicOptions

type Writer Uses

type Writer func(w io.Writer, c *Canvas) error

Writer can write a canvas to a writer

Directories

PathSynopsis
eps
examples/document
examples/go-chart
examples/gonum-plot
examples/graph
examples/html-canvasCode generated for package main by go-bindata DO NOT EDIT.
examples/map
examples/opengl
examples/preview
examples/stroke
examples/tex
examples/text
examples/title
font
htmlcanvas
pdf
rasterizer
svg
tex

Package canvas imports 32 packages (graph) and is imported by 17 packages. Updated 2020-05-29. Refresh now. Tools for package owners.