canvas

package module
Version: v0.0.0-...-920f346 Latest Latest
Warning

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

Go to latest
Published: Sep 26, 2021 License: MIT Imports: 29 Imported by: 44

README

Canvas

API reference User guide Go Report Card Coverage Status Donate

Canvas is a common vector drawing target that can output SVG, PDF, EPS, raster images (PNG, JPG, GIF, ...), HTML Canvas through WASM, OpenGL, and Gio. It has a wide range of path manipulation functionality such as flattening, stroking and dashing implemented. Additionally, it has a text formatter and embeds and subsets fonts (TTF, OTF, WOFF, WOFF2, or EOT) or converts them to outlines. It can be considered a Cairo or node-canvas alternative in Go. See the example below in Figure 1 for an overview of the functionality.

Preview

Figure 1: top-left you can see text being fitted into a box, justified using Donald Knuth's linea breaking algorithm to stretch the spaces between words to fill the whole width. You can observe a variety of styles and text decorations applied, as well as support for LTR/RTL mixing and complex scripts. In the bottom-right the word "stroke" is being stroked and drawn as a path. Top-right we see a LaTeX formula that has been converted to a path. Left of that we see an ellipse showcasing precise dashing, notably the length of e.g. the short dash is equal wherever it is on the curve. Note that the dashes themselves are elliptical arcs as well (thus exactly precise even if magnified greatly). To the right we see a closed polygon of four points being smoothed by cubic Béziers that are smooth along the whole path, and the blue line on the left shows a smoothed open path. On the bottom you can see a rotated rasterized image. The result is equivalent for all renderers (PNG, PDF, SVG, etc.).

Sponsors

Please see https://www.patreon.com/tdewolff for ways to contribute, otherwise please contact me directly!

Recent changes

  • Renderers have been moved from github.com/tdewolff/canvas/. to github.com/tdewolff/canvas/renderers/.
  • FontFamily.Use() is deprecated, use FontFamily.SetFeatures() (not yet used)
  • DPMM is now a function just like DPI: rasterizer.PNGWriter(5.0 * canvas.DPMM) => rasterizer.PNGWriter(canvas.DPMM(5.0))
  • FontFace is now passed around as a pointer
  • NewRichText now requires a default *FontFace to be passed
  • Use the latex build tag to use the original LaTeX expression parser
  • Renderer writers have been moved from renderers/ABC/abc.Writer to renderers/ABC
  • rasterizer.New is renamed to rasterizer.FromImage

Features

  • Path segment types: MoveTo, LineTo, QuadTo, CubeTo, ArcTo, Close
  • Precise path flattening, stroking, and dashing for all segment type uing papers (see below)
  • Smooth spline generation through points for open and closed paths
  • LaTeX to path conversion (native Go and CGO implementations available)
  • Font formats support
    • SFNT (such as TTF, OTF, WOFF, WOFF2, EOT) supporting TrueType, CFF, and CFF2 tables
  • HarfBuzz for text shaping (native Go and CGO implementations available)
  • FriBidi for text bidirectionality (native Go and CGO implementations available)
  • Donald Knuth's line breaking algorithm for text layout
  • sRGB compliance (use SRGBColorSpace, only available for rasterizer)
  • Font rendering with gamma correction of 1.43 (WIP)
  • Rendering targets
    • Raster images (PNG, GIF, JPEG, TIFF, BMP, WEBP)
    • PDF
    • SVG and SVGZ
    • PS and EPS
    • HTMLCanvas
    • OpenGL
  • Rendering sources
    • Canvas itself

Documentation

API documentation

User guide

Examples

Street Map: the centre of Amsterdam is drawn from data loaded from the Open Street Map API.

Mauna-Loa CO2 conentration: using data from the Mauna-Loa observatory, carbon dioxide concentrations over time are drawn

Document: an example of a text document.

OpenGL: an example using the OpenGL backend.

Gio: an example using the Gio backend.

TeX/PGF: an example showing the usage of the PGF (TikZ) LaTeX package as renderer in order to generated a PDF using LaTeX.

go-chart: example usage of the go-chart library, plotting a financial graph.

gonum/plot: example usage of the gonum/plot library.

Articles

My own

Papers

License

Released under the MIT license.

Documentation

Index

Constants

View Source
const (
	MoveToCmd = 1.0 << iota //  1.0
	LineToCmd               //  2.0
	QuadToCmd               //  4.0
	CubeToCmd               //  8.0
	ArcToCmd                // 16.0
	CloseCmd                // 32.0
)
View Source
const DefaultResolution = Resolution(96.0 * inchPerMm)

DefaultResolution is the default resolution used for font PPEMs and is set to 96 DPI.

Variables

View Source
var (
	A0        = Size{841.0, 1189.0}
	A1        = Size{594.0, 841.0}
	A2        = Size{420.0, 594.0}
	A3        = Size{297.0, 420.0}
	A4        = Size{210.0, 297.0}
	A5        = Size{148.0, 210.0}
	A6        = Size{105.0, 148.0}
	A7        = Size{74.0, 105.0}
	A8        = Size{52.0, 74.0}
	B0        = Size{1000.0, 1414.0}
	B1        = Size{707.0, 1000.0}
	B2        = Size{500.0, 707.0}
	B3        = Size{353.0, 500.0}
	B4        = Size{250.0, 353.0}
	B5        = Size{176.0, 250.0}
	B6        = Size{125.0, 176.0}
	B7        = Size{88.0, 125.0}
	B8        = Size{62.0, 88.0}
	B9        = Size{44.0, 62.0}
	B10       = Size{31.0, 44.0}
	C2        = Size{648.0, 458.0}
	C3        = Size{458.0, 324.0}
	C4        = Size{324.0, 229.0}
	C5        = Size{229.0, 162.0}
	C6        = Size{162.0, 114.0}
	D0        = Size{1090.0, 771.0}
	SRA0      = Size{1280.0, 900.0}
	SRA1      = Size{900.0, 640.0}
	SRA2      = Size{640.0, 450.0}
	SRA3      = Size{450.0, 320.0}
	SRA4      = Size{320.0, 225.0}
	RA0       = Size{1220.0, 860.0}
	RA1       = Size{860.0, 610.0}
	RA2       = Size{610.0, 430.0}
	Letter    = Size{215.9, 279.4}
	Legal     = Size{215.9, 355.6}
	Ledger    = Size{279.4, 431.8}
	Tabloid   = Size{431.8, 279.4}
	Executive = Size{184.1, 266.7}
)
View Source
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

View Source
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 and has no stroke.

View Source
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.

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

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

View Source
var Origin = Point{0.0, 0.0}
View Source
var Precision = 8

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

View Source
var Tolerance = 0.01

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

View Source
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.

Functions

func Equal

func Equal(a, b float64) bool

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

Types

type ArcsJoiner

type ArcsJoiner struct {
	GapJoiner Joiner
	Limit     float64
}

ArcsJoiner is an arcs joiner.

func (ArcsJoiner) Join

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

func (j ArcsJoiner) String() string

type BevelJoiner

type BevelJoiner struct{}

BevelJoiner is a bevel joiner.

func (BevelJoiner) Join

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

func (BevelJoiner) String() string

type ButtCapper

type ButtCapper struct{}

ButtCapper is a butt capper.

func (ButtCapper) Cap

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

func (ButtCapper) String() string

type CSSColor

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

func (color CSSColor) String() string

type Canvas

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

func New(width, height float64) *Canvas

New returns a new canvas with width and height in millimeters, that records all drawing operations into layers. The canvas can then be rendered to any other renderer.

func NewFromSize

func NewFromSize(size Size) *Canvas

NewFromSize returns a new canvas of given size in millimeters, that records all drawing operations into layers. The canvas can then be rendered to any other renderer.

func (*Canvas) Empty

func (c *Canvas) Empty() bool

Empty return true if the canvas is empty.

func (*Canvas) Fit

func (c *Canvas) Fit(margin float64)

Fit shrinks the canvas' size so all elements fit with a given margin in millimeters.

func (*Canvas) Render

func (c *Canvas) Render(r Renderer)

Render renders the accumulated canvas drawing operations to another renderer.

func (*Canvas) RenderImage

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

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

func (*Canvas) RenderPath

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

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

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

func (*Canvas) Reset

func (c *Canvas) Reset()

Reset empties the canvas.

func (*Canvas) SetZIndex

func (c *Canvas) SetZIndex(zindex int)

SetZIndex sets the z-index.

func (*Canvas) Size

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

Size returns the size of the canvas in millimeters.

func (*Canvas) WriteFile

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

WriteFile writes the canvas to a file named by filename using the given writer.

type Capper

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 ColorSpace

type ColorSpace interface {
	ToLinear(color.Color) color.RGBA
	FromLinear(color.Color) color.RGBA
}

ColorSpace defines the color space within the RGB color model. All colors passed to this library are assumed to be in the sRGB color space, which is a ubiquitous assumption in most software. This works great for most applications, but fails when blending semi-transparent layers. See an elaborate explaination at https://blog.johnnovak.net/2016/09/21/what-every-coder-should-know-about-gamma/, which goes into depth of the problems of using sRGB for blending and the need for gamma correction. In short, we need to transform the colors, which are in the sRGB color space, to the linear color space, perform blending, and then transform them back to the sRGB color space. Unfortunately, almost all software does blending the wrong way (all PDF renderers and browsers I've tested), so by default this library will do the same by using LinearColorSpace which does no conversion from sRGB to linear and back but blends directly in sRGB. Or in other words, it assumes that colors are given in the linear color space and that the output image is expected to be in the linear color space as well. For technical correctness we should really be using the SRGBColorSpace, which will convert from sRGB to linear space, do blending in linear space, and then go back to sRGB space.

var DefaultColorSpace ColorSpace = LinearColorSpace{}

DefaultColorSpace is set to LinearColorSpace to match other renderers.

type Context

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

func NewContext(r Renderer) *Context

NewContext returns a new context which is a wrapper around a renderer. Contexts maintain the state of the current path, path style, and view transformation matrix.

func (*Context) Arc

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 applied) 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, e.g. a difference of 810 degrees will draw one full circle and an arc over 90 degrees.

func (*Context) ArcTo

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's end point.

func (*Context) Close

func (c *Context) Close()

Close closes the current path.

func (*Context) ComposeView

func (c *Context) ComposeView(view Matrix)

ComposeView post-multiplies the current affine transformation matrix by the given matrix. This means that any draw action will first be transformed by the new view matrix (parameter) and then by the current view matrix (ie. `Context.View()`). `Context.ComposeView(Identity.ReflectX())` is the same as `Context.ReflectX()`.

func (*Context) CoordView

func (c *Context) CoordView() Matrix

CoordView returns the current affine transformation matrix through which all operation coordinates will be transformed.

func (*Context) CubeTo

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

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

DrawImage draws an image at position (x,y) using the current draw state and the given resolution in pixels-per-millimeter. A higher resolution will draw a smaller image (ie. more image pixels per millimeter of document).

func (*Context) DrawPath

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

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

DrawText draws text at position (x,y) using the current draw state.

func (*Context) Fill

func (c *Context) Fill()

Fill fills the current path and resets the path.

func (*Context) FillStroke

func (c *Context) FillStroke()

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

func (*Context) Height

func (c *Context) Height() float64

Height returns the height of the canvas in millimeters.

func (*Context) LineTo

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

LineTo adds a linear path to (x,y).

func (*Context) MoveTo

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

MoveTo moves the path to (x,y) without connecting with the previous 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 of overlapping paths depends on the FillRule.

func (*Context) Pop

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

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

func (c *Context) Push()

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

func (*Context) QuadTo

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

func (c *Context) ReflectX()

ReflectX inverts the X axis of the view.

func (*Context) ReflectXAbout

func (c *Context) ReflectXAbout(x float64)

ReflectXAbout inverts the X axis of the view about the given X coordinate.

func (*Context) ReflectY

func (c *Context) ReflectY()

ReflectY inverts the Y axis of the view.

func (*Context) ReflectYAbout

func (c *Context) ReflectYAbout(y float64)

ReflectYAbout inverts the Y axis of the view about the given Y coordinate.

func (*Context) ResetStyle

func (c *Context) ResetStyle()

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

func (*Context) ResetView

func (c *Context) ResetView()

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

func (*Context) Rotate

func (c *Context) Rotate(rot float64)

Rotate rotates the view counter clockwise with rot in degrees.

func (*Context) RotateAbout

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

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

func (*Context) Scale

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

Scale scales the view.

func (*Context) ScaleAbout

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

ScaleAbout scales the view around (x,y).

func (*Context) SetCoordRect

func (c *Context) SetCoordRect(rect Rect, width, height float64)

SetCoordRect sets the current affine transformation matrix through which all operation coordinates will be transformed. It will transform coordinates from (0,0)--(width,height) to the target `rect`.

func (*Context) SetCoordSystem

func (c *Context) SetCoordSystem(coordSystem CoordSystem)

SetCoordSystem sets the current affine transformation matrix through which all operation coordinates will be transformed as a Cartesian coordinate system.

func (*Context) SetCoordView

func (c *Context) SetCoordView(coordView Matrix)

SetCoordView sets the current affine transformation matrix through which all operation coordinates will be transformed. See `Matrix` for how transformations work.

func (*Context) SetDashes

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 millimeters from where to start. Negative values are allowed.

func (*Context) SetFillColor

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

SetFillColor sets the color to be used for filling operations.

func (*Context) SetFillRule

func (c *Context) SetFillRule(rule FillRule)

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

func (*Context) SetStrokeCapper

func (c *Context) SetStrokeCapper(capper Capper)

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

func (*Context) SetStrokeColor

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

SetStrokeColor sets the color to be used for stroking operations.

func (*Context) SetStrokeJoiner

func (c *Context) SetStrokeJoiner(joiner Joiner)

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

func (*Context) SetStrokeWidth

func (c *Context) SetStrokeWidth(width float64)

SetStrokeWidth sets the width in millimeters for stroking operations.

func (*Context) SetView

func (c *Context) SetView(view Matrix)

SetView sets the current affine transformation matrix through which all operations will be transformed. See `Matrix` for how transformations work.

func (*Context) SetZIndex

func (c *Context) SetZIndex(zindex int)

SetZIndex sets the z-index. This will call the renderer's `SetZIndex` function only if it exists (in this case only for `Canvas`).

func (*Context) Shear

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

Shear shear stretches the view.

func (*Context) ShearAbout

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

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

func (*Context) Stroke

func (c *Context) Stroke()

Stroke strokes the current path and resets the path.

func (*Context) Translate

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

Translate moves the view.

func (*Context) View

func (c *Context) View() Matrix

View returns the current affine transformation matrix through which all operations will be transformed.

func (*Context) Width

func (c *Context) Width() float64

Width returns the width of the canvas in millimeters.

type CoordSystem

type CoordSystem int

CoordSystem is the coordinate system, which can be either of the four cartesian quadrants. Most useful are the I'th and IV'th quadrants. CartesianI is the default quadrant with the zero-point in the bottom-left (the default for mathematics). The CartesianII has its zero-point in the bottom-right, CartesianIII in the top-right, and CartesianIV in the top-left (often used as default for printing devices). See https://en.wikipedia.org/wiki/Cartesian_coordinate_system#Quadrants_and_octants for an explanation.

const (
	CartesianI CoordSystem = iota
	CartesianII
	CartesianIII
	CartesianIV
)

see CoordSystem

type FillRule

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 paths, whichever their direction.

const (
	NonZero FillRule = iota
	EvenOdd
)

see FillRule

type Font

type Font struct {
	*font.SFNT
	// contains filtered or unexported fields
}

Font defines an SFNT font such as TTF or OTF.

func (*Font) Destroy

func (f *Font) Destroy()

Destroy should be called when using HarfBuzz to free the C resources.

func (*Font) Name

func (f *Font) Name() string

Name returns the name of the font.

func (*Font) SetFeatures

func (f *Font) SetFeatures(features string)

SetFeatures sets the font features (not yet supported).

func (*Font) SetVariations

func (f *Font) SetVariations(variations string)

SetVariations sets the font variations (not yet supported).

func (*Font) Style

func (f *Font) Style() FontStyle

Style returns the style of the font.

func (*Font) SubsetID

func (f *Font) SubsetID(glyphID uint16) uint16

SubsetID maps a glyphID of the original font to the subsetted font. If the glyphID is not subsetted, it will be added to the map.

func (*Font) SubsetIDs

func (f *Font) SubsetIDs() []uint16

SubsetIDs returns all subsetted IDs in the order of appearance.

type FontDecorator

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

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

var FontDashedUnderline FontDecorator = dashedUnderline{}

FontDashedUnderline is a font decoration that draws a dashed line under the text.

var FontDottedUnderline FontDecorator = dottedUnderline{}

FontDottedUnderline is a font decoration that draws a dotted line under the text.

var FontDoubleUnderline FontDecorator = doubleUnderline{}

FontDoubleUnderline is a font decoration that draws two lines under the text.

var FontOverline FontDecorator = overline{}

FontOverline is a font decoration that draws a line over the text.

var FontSawtoothUnderline FontDecorator = sawtoothUnderline{}

FontSawtoothUnderline is a font decoration that draws a wavy sawtooth path under the text.

var FontSineUnderline FontDecorator = sineUnderline{}

FontSineUnderline is a font decoration that draws a wavy sine path under the text.

var FontStrikethrough FontDecorator = strikethrough{}

FontStrikethrough is a font decoration that draws a line through the text.

var FontUnderline FontDecorator = underline{}

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

var FontWavyUnderline FontDecorator = wavyUnderline{}

FontWavyUnderline is a font decoration that draws a wavy path under the text.

type FontFace

type FontFace struct {
	Font *Font

	Size    float64 // in pt
	Style   FontStyle
	Variant FontVariant

	Color color.RGBA
	Deco  []FontDecorator

	// faux styles for bold, italic, and sub- and superscript
	FauxBold, FauxItalic float64
	XOffset, YOffset     int32

	Language  string
	Script    text.Script
	Direction text.Direction
	// contains filtered or unexported fields
}

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

func (*FontFace) Decorate

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

Decorate will return the decoration path over a given width in millimeters.

func (*FontFace) Equals

func (face *FontFace) Equals(other *FontFace) bool

Equals returns true when two font face are equal.

func (*FontFace) HasDecoration

func (face *FontFace) HasDecoration() bool

HasDecoration returns true if the font face has decorations enabled.

func (*FontFace) Metrics

func (face *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

func (face *FontFace) Name() string

Name returns the name of the underlying font.

func (*FontFace) PPEM

func (face *FontFace) PPEM(resolution Resolution) uint16

PPEM returns the pixels-per-EM for a given resolution of the font face.

func (*FontFace) TextWidth

func (face *FontFace) TextWidth(s string) float64

TextWidth returns the width of a given string in millimeters.

func (*FontFace) ToPath

func (face *FontFace) ToPath(s string) (*Path, float64, error)

ToPath converts a string to its glyph paths.

type FontFamily

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

FontFamily contains a family of fonts (bold, italic, ...). Allowing to select an italic style as the native italic font or to use faux italic if not present.

func NewFontFamily

func NewFontFamily(name string) *FontFamily

NewFontFamily returns a new font family.

func (*FontFamily) Destroy

func (family *FontFamily) Destroy()

Destroy should be called when using HarfBuzz to free the C resources.

func (*FontFamily) Face

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 points and its style.

func (*FontFamily) LoadFont

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

LoadFont loads a font from memory.

func (*FontFamily) LoadFontCollection

func (family *FontFamily) LoadFontCollection(filename string, index int, style FontStyle) error

LoadFontCollection loads a font from a collection file and uses the font at the specified index.

func (*FontFamily) LoadFontFile

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

LoadFontFile loads a font from a file.

func (*FontFamily) LoadLocalFont

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

LoadLocalFont loads a font from the system's fonts.

func (*FontFamily) Name

func (family *FontFamily) Name() string

Name returns the name of the font family.

func (*FontFamily) SetFeatures

func (family *FontFamily) SetFeatures(features string)

SetFeatures sets the font features (not yet supported).

func (*FontFamily) SetVariations

func (family *FontFamily) SetVariations(variations string)

SetVariations sets the font variations (not yet supported).

type FontMetrics

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

	XMin, YMin float64
	XMax, YMax 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.

func (FontMetrics) String

func (m FontMetrics) String() string

type FontStyle

type FontStyle int

FontStyle defines the font style to be used for the font. It specifies a boldness with optionally italic, e.g. FontBlack | FontItalic will specify a black boldness (a font-weight of 800 in CSS) and italic.

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

see FontStyle

func (FontStyle) CSS

func (style FontStyle) CSS() int

CSS returns the CSS boldness value for the font face.

func (FontStyle) Italic

func (style FontStyle) Italic() bool

Italic returns true if italic.

func (FontStyle) Weight

func (style FontStyle) Weight() FontStyle

Weight returns the font weight (FontRegular, FontBold, ...)

type FontVariant

type FontVariant int

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

const (
	FontNormal FontVariant = iota
	FontSubscript
	FontSuperscript
	FontSmallcaps
)

see FontVariant

type GammaColorSpace

type GammaColorSpace struct {
	Gamma float64
}

GammaColorSpace assumes that input colors and output images are gamma-corrected with the given gamma value. The sRGB space uses a gamma=2.4 for most of the curve, but will on average have a gamma=2.2 best approximating the sRGB curve. See https://en.wikipedia.org/wiki/SRGB#The_sRGB_transfer_function_(%22gamma%22). According to https://www.puredevsoftware.com/blog/2019/01/22/sub-pixel-gamma-correct-font-rendering/, a gamma=1.43 is recommended for fonts.

func (GammaColorSpace) FromLinear

func (cs GammaColorSpace) FromLinear(col color.Color) color.RGBA

func (GammaColorSpace) ToLinear

func (cs GammaColorSpace) ToLinear(col color.Color) color.RGBA

type Image

type Image struct {
	image.Image
	Mimetype string
	Bytes    []byte
}

Image is a raster image. Keeping the original bytes allows the renderer to optimize rendering in some cases.

func NewJPEGImage

func NewJPEGImage(r io.Reader) (Image, error)

NewJPEGImage parses a JPEG image.

func NewPNGImage

func NewPNGImage(r io.Reader) (Image, error)

NewPNGImage parses a PNG image

type ImageEncoding

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

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

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

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 LinearColorSpace

type LinearColorSpace struct{}

LinearColorSpace is the default color space that does not do color space conversion for blending purposes. This is only correct if the input colors and output images are assumed to be in the linear color space so that blending is in linear space as well. In general though, we assume that input colors and output images are using the sRGB color space almost ubiquitously, resulting in blending in sRGB space which is wrong! Even though it is technically incorrect, many PDF viewers and browsers do this anyway.

func (LinearColorSpace) FromLinear

func (LinearColorSpace) FromLinear(col color.Color) color.RGBA

func (LinearColorSpace) ToLinear

func (LinearColorSpace) ToLinear(col color.Color) color.RGBA

type Matrix

type Matrix [2][3]float64

Matrix is used for affine transformations, which are transformations such as translation, scaling, reflection, rotation, shear stretching. See https://en.wikipedia.org/wiki/Affine_transformation#Image_transformation for an overview of the transformations. The affine transformation matrix contains all transformations in a matrix, where we can concatenate transformations to apply them sequentially. Be aware that concatenated transformations 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

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

func (m Matrix) Det() float64

Det returns the matrix determinant.

func (Matrix) Dot

func (m Matrix) Dot(p Point) Point

Dot returns the dot product between the matrix and the given vector, i.e. applying the transformation.

func (Matrix) Eigen

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

func (m Matrix) Equals(q Matrix) bool

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

func (Matrix) Inv

func (m Matrix) Inv() Matrix

Inv returns the matrix inverse.

func (Matrix) IsRigid

func (m Matrix) IsRigid() bool

IsRigid is true if the matrix is orthogonal and consists of only translation, rotation, and reflection transformations.

func (Matrix) IsSimilarity

func (m Matrix) IsSimilarity() bool

IsSimilarity is true if the matrix consists of only translation, rotation, reflection, and scaling transformations.

func (Matrix) IsTranslation

func (m Matrix) IsTranslation() bool

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

func (Matrix) Mul

func (m Matrix) Mul(q Matrix) Matrix

Mul multiplies the current matrix by the given matrix, i.e. combining transformations.

func (Matrix) Pos

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

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

func (Matrix) ReflectX

func (m Matrix) ReflectX() Matrix

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

func (Matrix) ReflectXAbout

func (m Matrix) ReflectXAbout(x float64) Matrix

ReflectXAbout adds a horizontal reflection transformation about x.

func (Matrix) ReflectY

func (m Matrix) ReflectY() Matrix

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

func (Matrix) ReflectYAbout

func (m Matrix) ReflectYAbout(y float64) Matrix

ReflectYAbout adds a vertical reflection transformation about y.

func (Matrix) Rotate

func (m Matrix) Rotate(rot float64) Matrix

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

func (Matrix) RotateAbout

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

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

func (Matrix) Scale

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

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

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

func (Matrix) Shear

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

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

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

func (Matrix) String

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

func (m Matrix) T() Matrix

T returns the matrix transpose.

func (Matrix) ToSVG

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

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

Translate adds a translation in x and y.

type MiterJoiner

type MiterJoiner struct {
	GapJoiner Joiner
	Limit     float64
}

MiterJoiner is a miter joiner.

func (MiterJoiner) Join

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

func (j MiterJoiner) String() string

type Path

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

Path defines a vector path in 2D using a series of 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 is 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 in the range [0, 2*PI) and we scale the radii up if they appear too small to fit the arc.

func Arc

func Arc(r, theta0, theta1 float64) *Path

Arc returns a circular arc with radius r 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, e.g. a difference of 810 degrees will draw one full circle and an arc over 90 degrees.

func BeveledRectangle

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

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

func Circle

func Circle(r float64) *Path

Circle returns a circle of radius r.

func Ellipse

func Ellipse(rx, ry float64) *Path

Ellipse returns an ellipse of radii rx and ry.

func EllipticalArc

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

EllipticalArc returns 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, e.g. a difference of 810 degrees will draw one full circle and an arc over 90 degrees.

func Grid

func Grid(w, h float64, nx, ny int, r float64) *Path

Grid returns a stroked grid of width w and height h, with grid line thickness r, and the number of cells horizontally and vertically as nx and ny respectively.

func Line

func Line(x, y float64) *Path

Line returns a line segment of from (0,0) to (x,y).

func MustParseSVG

func MustParseSVG(s string) *Path

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

func ParseLaTeX

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

func ParseSVG

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

ParseSVG parses an SVG path data string.

func Rectangle

func Rectangle(w, h float64) *Path

Rectangle returns a rectangle of width w and height h.

func RegularPolygon

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

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

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

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

func StarPolygon

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

func (p *Path) And(q *Path) []*Path

func (*Path) Append

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

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

func (*Path) Arc

func (p *Path) 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, e.g. a difference of 810 degrees will draw one full circle and an arc over 90 degrees.

func (*Path) ArcTo

func (p *Path) 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's end point.

func (*Path) Bounds

func (p *Path) Bounds() Rect

Bounds returns the bounding box rectangle of the path.

func (*Path) CCW

func (p *Path) CCW() bool

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

func (*Path) Close

func (p *Path) Close()

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

func (p *Path) Closed() bool

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

func (*Path) Coords

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

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

func (*Path) Copy

func (p *Path) Copy() *Path

Copy returns a copy of p.

func (*Path) CubeTo

func (p *Path) 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 (*Path) Cut

func (p *Path) Cut(q *Path) []*Path

func (*Path) Dash

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 into the path). Dash will be applied to each subpath independently.

func (*Path) Div

func (p *Path) Div(q *Path) []*Path

func (*Path) Empty

func (p *Path) Empty() bool

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

func (*Path) Equals

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

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

func (*Path) Filling

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

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

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, i.e. gets filled. This depends on the FillRule.

func (*Path) Intersections

func (p *Path) Intersections(q *Path) intersections

func (*Path) Iterate

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 over the path commands and calls the respective functions move, line, quad, cube, arc, close when encountering MoveTo, LineTo, QuadTo, CubeTo, ArcTo, Close commands respectively. DEPRECATED

func (*Path) Join

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

Join joins path q to p and returns a new path if successful (otherwise either p or q are returned). It's 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

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

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

LineTo adds a linear path to (x,y).

func (*Path) Markers

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

Markers returns an array of start, mid and end marker paths along the path at the 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

func (p *Path) 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 depends on the FillRule.

func (*Path) Not

func (p *Path) Not(q *Path) []*Path

func (*Path) Offset

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

func (p *Path) Or(q *Path) []*Path

func (*Path) Pos

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

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

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

func (*Path) ReplaceArcs

func (p *Path) ReplaceArcs() *Path

ReplaceArcs replaces ArcTo commands by CubeTo commands.

func (*Path) Reverse

func (p *Path) Reverse() *Path

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

func (*Path) Segments

func (p *Path) Segments() []Segment

Segments returns the path segments as a slice of segment structures.

func (*Path) Split

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

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

func (p *Path) StartPos() Point

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

func (*Path) String

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

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 elements. 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) Tile

func (p *Path) Tile(n, m int, tiler Tiler) *Path

func (*Path) ToPDF

func (p *Path) ToPDF() string

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

func (*Path) ToPS

func (p *Path) ToPS() string

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

func (*Path) ToRasterizer

func (p *Path) ToRasterizer(ras *vector.Rasterizer, resolution Resolution)

ToRasterizer rasterizes the path using the given rasterizer and resolution.

func (*Path) ToSVG

func (p *Path) ToSVG() string

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

func (*Path) Transform

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

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

func (*Path) Translate

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

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

func (*Path) Triangulate

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

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

func (*Path) Xor

func (p *Path) Xor(q *Path) []*Path

type Point

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 EllipsePos

func EllipsePos(rx, ry, phi, cx, cy, theta float64) Point

EllipsePos returns the position on the ellipse at angle theta.

func (Point) Add

func (p Point) Add(q Point) Point

Add adds Q to P.

func (Point) Angle

func (p Point) Angle() float64

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

func (Point) AngleBetween

func (p Point) AngleBetween(q Point) float64

AngleBetween returns the angle between OP and OQ.

func (Point) Div

func (p Point) Div(f float64) Point

Div divides x and y by f.

func (Point) Dot

func (p Point) Dot(q Point) float64

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

func (Point) Equals

func (p Point) Equals(q Point) bool

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

func (Point) Interpolate

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

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

func (Point) IsZero

func (p Point) IsZero() bool

IsZero returns true if P is exactly zero.

func (Point) Length

func (p Point) Length() float64

Length returns the length of OP.

func (Point) Mul

func (p Point) Mul(f float64) Point

Mul multiplies x and y by f.

func (Point) Neg

func (p Point) Neg() Point

Neg negates x and y.

func (Point) Norm

func (p Point) Norm(length float64) Point

Norm normalized OP to be of given length.

func (Point) PerpDot

func (p Point) PerpDot(q Point) float64

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

func (Point) Rot

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

Rot rotates the line OP by phi radians CCW.

func (Point) Rot90CCW

func (p Point) Rot90CCW() Point

Rot90CCW rotates the line OP by 90 degrees CCW.

func (Point) Rot90CW

func (p Point) Rot90CW() Point

Rot90CW rotates the line OP by 90 degrees CW.

func (Point) Slope

func (p Point) Slope() float64

Slope returns the slope between OP, i.e. y/x.

func (Point) String

func (p Point) String() string

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

func (Point) Sub

func (p Point) Sub(q Point) Point

Sub subtracts Q from P.

type Polyline

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

func PolylineFromPath(p *Path) *Polyline

PolylineFromPath returns a polyline from the given path by approximating it by linear line segments, i.e. by flattening.

func PolylineFromPathCoords

func PolylineFromPathCoords(p *Path) *Polyline

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

func (*Polyline) Add

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

Add adds a new point to the polyline.

func (*Polyline) Coords

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

Coords returns the list of coordinates of the polyline.

func (*Polyline) FillCount

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

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, i.e. gets filled. This depends on the FillRule.

func (*Polyline) Smoothen

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 segments too.

func (*Polyline) ToPath

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

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

func (r Rect) Add(q Rect) Rect

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

func (Rect) Equals

func (r Rect) Equals(q Rect) bool

Equals returns true if rectangles are equal with tolerance Epsilon.

func (Rect) Move

func (r Rect) Move(p Point) Rect

Move translates the rect.

func (Rect) String

func (r Rect) String() string

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

func (Rect) ToPath

func (r Rect) ToPath() *Path

ToPath converts the rectangle to a path.

func (Rect) Transform

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

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 images.

type Resolution

type Resolution float64

Resolution is used for rasterizing. Higher resolutions will result in larger images.

func DPI

func DPI(dpi float64) Resolution

DPI (dots-per-inch) for the resolution of rasterization.

func DPMM

func DPMM(dpmm float64) Resolution

DPMM (dots-per-millimeter) for the resolution of rasterization.

func (Resolution) DPI

func (res Resolution) DPI() float64

DPI returns the resolution in dots-per-inch.

func (Resolution) DPMM

func (res Resolution) DPMM() float64

DPMM returns the resolution in dots-per-millimeter.

type RichText

type RichText struct {
	*strings.Builder
	// contains filtered or unexported fields
}

RichText allows to build up a rich text with text spans of different font faces and fitting that into a box using Donald Knuth's line breaking algorithm. TODO: RichText add support for decoration spans to properly underline the spaces betwee words too

func NewRichText

func NewRichText(face *FontFace) *RichText

NewRichText returns a new rich text with the given default font face.

func (*RichText) Add

func (rt *RichText) Add(face *FontFace, text string) *RichText

Add adds a string with a given font face to the rich text.

func (*RichText) Reset

func (rt *RichText) Reset()

Reset resets the rich text to its initial state.

func (*RichText) SetFace

func (rt *RichText) SetFace(face *FontFace)

SetFace sets the font face.

func (*RichText) SetFaceSpan

func (rt *RichText) SetFaceSpan(face *FontFace, start, end int)

SetFaceSpan sets the font face between start and end measured in bytes.

func (*RichText) SetWritingMode

func (rt *RichText) SetWritingMode(mode WritingMode)

SetWritingMode sets the final writing mode of the rich text.

func (*RichText) ToText

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 using Donald Knuth's line breaking algorithm.

type RoundCapper

type RoundCapper struct{}

RoundCapper is a round capper.

func (RoundCapper) Cap

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

func (RoundCapper) String() string

type RoundJoiner

type RoundJoiner struct{}

RoundJoiner is a round joiner.

func (RoundJoiner) Join

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

func (RoundJoiner) String() string

type SRGBColorSpace

type SRGBColorSpace struct{}

SRGBColorSpace assumes that input colors and output images are in the sRGB color space (ubiquitous in almost all applications), which implies that for blending we need to convert to the linear color space, do blending, and then convert back to the sRGB color space. This will give technically correct blending, but may differ from common PDF viewer and browsers (which are wrong).

func (SRGBColorSpace) FromLinear

func (SRGBColorSpace) FromLinear(col color.Color) color.RGBA

func (SRGBColorSpace) ToLinear

func (SRGBColorSpace) ToLinear(col color.Color) color.RGBA

type Segment

type Segment struct {
	Cmd        float64
	Start, End Point
	// contains filtered or unexported fields
}

Segment is a path command.

func (Segment) Arc

func (seg Segment) Arc() (float64, float64, float64, bool, bool)

Arc returns the arguments for arcs (rx,ry,rot,large,sweep).

func (Segment) CP1

func (seg Segment) CP1() Point

CP1 returns the first control point for quadratic and cubic Béziers.

func (Segment) CP2

func (seg Segment) CP2() Point

CP2 returns the second control point for cubic Béziers.

type Size

type Size struct {
	W, H float64
}

Size defines a size (width and height).

type SquareCapper

type SquareCapper struct{}

SquareCapper is a square capper.

func (SquareCapper) Cap

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

func (SquareCapper) String() string

type Style

type Style struct {
	FillColor    color.RGBA
	StrokeColor  color.RGBA
	StrokeWidth  float64
	StrokeCapper Capper
	StrokeJoiner Joiner
	DashOffset   float64
	Dashes       []float64
	FillRule     // TODO: test for all renderers
}

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

func (Style) HasFill

func (style Style) HasFill() bool

HasFill returns true if the style has a fill

func (Style) HasStroke

func (style Style) HasStroke() bool

HasStroke returns true if the style has a stroke

func (Style) IsDashed

func (style Style) IsDashed() bool

IsDashed returns true if the style has dashes

type Text

type Text struct {
	Face *FontFace
	Mode WritingMode
	// contains filtered or unexported fields
}

Text holds the representation of a text object.

func NewTextBox

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

NewTextBox is an advanced text formatter that will format text placement based on the settings. It takes a single font face, a string, the width or height of the box (can be zero to disable), 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

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

NewTextLine is a simple text line using a single font face, a string (supporting new lines) and horizontal alignment (Left, Center, Right). The text's baseline will be drawn on the current coordinate.

func (*Text) Bounds

func (t *Text) Bounds() Rect

Bounds returns the bounding rectangle that defines the text box.

func (*Text) Empty

func (t *Text) Empty() bool

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

func (*Text) Fonts

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

Fonts returns the list of fonts used.

func (*Text) Heights

func (t *Text) Heights() (float64, float64)

Heights returns the top and bottom position of the first and last line respectively.

func (*Text) OutlineBounds

func (t *Text) OutlineBounds() Rect

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

func (*Text) RenderAsPath

func (t *Text) RenderAsPath(r Renderer, m Matrix, resolution Resolution)

RenderAsPath renders the text and its decorations converted to paths, calling r.RenderPath.

func (*Text) WalkDecorations

func (t *Text) WalkDecorations(callback func(col color.RGBA, deco *Path))

WalkDecorations calls the callback for each color of decoration used per line.

func (*Text) WalkSpans

func (t *Text) WalkSpans(callback func(x, y float64, span TextSpan))

WalkSpans calls the callback for each text span per line.

type TextAlign

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

func (TextAlign) String

func (ta TextAlign) String() string

type TextSpan

type TextSpan struct {
	Width     float64
	Face      *FontFace
	Text      string
	Glyphs    []canvasText.Glyph
	Direction canvasText.Direction
	// contains filtered or unexported fields
}

TextSpan is a span of text.

type Tiler

type Tiler struct {
	A, B Point
	Ms   []Matrix
}

func P1

func P1(x, y, rot float64) Tiler

func Pg

func Pg(x, y float64) Tiler

func Pm

func Pm(x, y float64) Tiler

type Writer

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

Writer can write a canvas to a writer.

type WritingMode

type WritingMode int

WritingMode specifies how the text lines should be laid out.

const (
	HorizontalTB WritingMode = iota
	VerticalRL
	VerticalLR
)

see WritingMode

func (WritingMode) String

func (wm WritingMode) String() string

Directories

Path Synopsis
examples
gio
html-canvas
Code generated for package main by go-bindata DO NOT EDIT.
Code generated for package main by go-bindata DO NOT EDIT.
map
tex
gio
pdf
ps
svg
tex
resources

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL