iLoveElysia/openbilibili
1
0
Fork 0
mirror of https://github.com/iLoveElysia/openbilibili.git synced 2026-03-14 05:46:26 -05:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Donny
2019-04-22 20:46:32 +08:00
commit 49ab8aadd1
25441 changed files with 4055000 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
vendor/github.com/ajstarks/svgo/BUILD generated vendored Normal file
View File

@@ -0,0 +1,31 @@
package(default_visibility = ["//visibility:public"])
load(
"@io_bazel_rules_go//go:def.bzl",
"go_library",
)
go_library(
name = "go_default_library",
srcs = [
"doc.go",
"svg.go",
],
importpath = "github.com/ajstarks/svgo",
tags = ["automanaged"],
visibility = ["//visibility:public"],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

3
vendor/github.com/ajstarks/svgo/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,3 @@
The contents of this repository are Licensed under
the Creative Commons Attribution 3.0 license as described in
http://creativecommons.org/licenses/by/3.0/us/

683
vendor/github.com/ajstarks/svgo/README.markdown generated vendored Normal file
View File

@@ -0,0 +1,683 @@
# SVGo: A Go library for SVG generation #
The library generates SVG as defined by the Scalable Vector Graphics 1.1 Specification (<http://www.w3.org/TR/SVG11/>).
Output goes to the specified io.Writer.
## Supported SVG elements and functions ##
### Shapes, lines, text
circle, ellipse, polygon, polyline, rect (including roundrects), line, text
### Paths
general, arc, cubic and quadratic bezier paths,
### Image and Gradients
image, linearGradient, radialGradient,
### Transforms ###
translate, rotate, scale, skewX, skewY
### Filter Effects
filter, feBlend, feColorMatrix, feColorMatrix, feComponentTransfer, feComposite, feConvolveMatrix, feDiffuseLighting,
feDisplacementMap, feDistantLight, feFlood, feGaussianBlur, feImage, feMerge, feMorphology, feOffset, fePointLight,
feSpecularLighting, feSpotLight,feTile, feTurbulence
### Metadata elements ###
desc, defs, g (style, transform, id), marker, mask, pattern, title, (a)ddress, link, script, use
## Building and Usage ##
See svgdef.[svg|png|pdf] for a graphical view of the function calls
Usage: (assuming GOPATH is set)
go get github.com/ajstarks/svgo
go install github.com/ajstarks/svgo/...
You can use godoc to browse the documentation from the command line:
$ go doc github.com/ajstarks/svgo
a minimal program, to generate SVG to standard output.
package main
import (
"github.com/ajstarks/svgo"
"os"
)
func main() {
width := 500
height := 500
canvas := svg.New(os.Stdout)
canvas.Start(width, height)
canvas.Circle(width/2, height/2, 100)
canvas.Text(width/2, height/2, "Hello, SVG", "text-anchor:middle;font-size:30px;fill:white")
canvas.End()
}
Drawing in a web server: (http://localhost:2003/circle)
package main
import (
"log"
"github.com/ajstarks/svgo"
"net/http"
)
func main() {
http.Handle("/circle", http.HandlerFunc(circle))
err := http.ListenAndServe(":2003", nil)
if err != nil {
log.Fatal("ListenAndServe:", err)
}
}
func circle(w http.ResponseWriter, req *http.Request) {
w.Header().Set("Content-Type", "image/svg+xml")
s := svg.New(w)
s.Start(500, 500)
s.Circle(250, 250, 125, "fill:none;stroke:black")
s.End()
}
You may view the SVG output with a browser that supports SVG (tested on Chrome, Opera, Firefox and Safari), or any other SVG user-agent such as Batik Squiggle.
### Graphics Sketching with SVGo and svgplay ###
Combined with the svgplay command, SVGo can be used to "sketch" with code in a browser.
To use svgplay and SVGo, first go to a directory with your code, and run:
$ svgplay
2014/06/25 22:05:28 ☠ ☠ ☠ Warning: this server allows a client connecting to 127.0.0.1:1999 to execute code on this computer ☠ ☠ ☠
Next open your browser to the svgplay server you just started.
svgplay only listens on localhost, and uses port 1999 (guess which year SVG was first introduced) by default
http://localhost:1999/
Enter your code in the textarea, and when you are ready to run press Shift--Enter. The code will be compiled, with the results
on the right. To update, change the code and repeat. Note that compilation errors are shown in red under the code. In order for svgplay/SVGo to work, make sure that the io.Writer specified with the New function is os.Stdout.
If you want to sketch with an existing file, enter its URL:
http://localhost:1999/foo.go
![SVGplay](https://farm4.staticflickr.com/3859/14322978157_31c0114850.jpg)
### SVGo Papers and presentations ###
* SVGo paper from SVGOpen 2011 <http://www.svgopen.org/2011/papers/34-SVGo_a_Go_Library_for_SVG_generation>
* Programming Pictures with SVGo <https://speakerdeck.com/u/ajstarks/p/programming-pictures-with-svgo>
* SVGo Workshop <https://speakerdeck.com/u/ajstarks/p/svgo-workshop>
### Tutorial Video ###
A video describing how to use the package can be seen on YouTube at <http://www.youtube.com/watch?v=ze6O2Dj5gQ4>
## Package contents ##
* svg.go: Library
* newsvg: Coding template command
* svgdef: Creates a SVG representation of the API
* android: The Android logo
* bubtrail: Bubble trails
* bulletgraph: Bullet Graphs (via Stephen Few)
* colortab: Display SVG named colors with RGB values
* compx: Component diagrams
* flower: Random "flowers"
* fontcompare: Compare two fonts
* f50: Get 50 photos from Flickr based on a query
* fe: Filter effects
* funnel: Funnel from transparent circles
* gradient: Linear and radial gradients
* html5logo: HTML5 logo with draggable elements
* imfade: Show image fading
* lewitt: Version of Sol Lewitt's Wall Drawing 91
* ltr: Layer Tennis Remixes
* marker: Test markers
* paths: Demonstrate SVG paths
* pattern: Test patterns
* planets: Show the scale of the Solar system
* pmap: Proportion maps
* randcomp: Compare random number generators
* richter: Gerhard Richter's 256 colors
* rl: Random lines (port of a Processing demo)
* skewabc: Skew ABC
* stockproduct: Visualize product and stock prices
* svgopher: SVGo Mascot
* svgplay: SVGo sketching server
* svgplot: Plot data
* svgrid: Compose SVG files in a grid
* tsg: Twitter Search Grid
* tumblrgrid: Tumblr picture grid
* turbulence: Turbulence filter effect
* vismem: Visualize data from files
* webfonts: "Hello, World" with Google Web Fonts
* websvg: Generate SVG as a web server
## Functions and types ##
Many functions use x, y to specify an object's location, and w, h to specify the object's width and height.
Where applicable, a final optional argument specifies the style to be applied to the object.
The style strings follow the SVG standard; name:value pairs delimited by semicolons, or a
series of name="value" pairs. For example: `"fill:none; opacity:0.3"` or `fill="none" opacity="0.3"` (see: <http://www.w3.org/TR/SVG11/styling.html>)
The SVG type:
type SVG struct {
Writer io.Writer
}
Most operations are methods on this type, specifying the destination io.Writer.
The Offcolor type:
type Offcolor struct {
Offset uint8
Color string
Opacity float64
}
is used to specify the offset, color, and opacity of stop colors in linear and radial gradients
The Filterspec type:
type Filterspec struct {
In string
In2 string
Result string
}
is used to specify inputs and results for filter effects
### Structure, Scripting, Metadata, Transformation and Links ###
New(w io.Writer) *SVG
Constructor, Specify the output destination.
Start(w int, h int, attributes ...string)
begin the SVG document with the width w and height h. Optionally add additional elements
(such as additional namespaces or scripting events)
<http://www.w3.org/TR/SVG11/struct.html#SVGElement>
Startview(w, h, minx, miny, vw, vh int)
begin the SVG document with the width w, height h, with a viewBox at minx, miny, vw, vh.
<http://www.w3.org/TR/SVG11/struct.html#SVGElement>
Startunit(w int, h int, unit string, ns ...string)
begin the SVG document, with width and height in the specified units. Optionally add additional elements
(such as additional namespaces or scripting events)
<http://www.w3.org/TR/SVG11/struct.html#SVGElement>
Startpercent(w int, h int, ns ...string)
begin the SVG document, with width and height in percent. Optionally add additional elements
(such as additional namespaces or scripting events)
<http://www.w3.org/TR/SVG11/struct.html#SVGElement>
StartviewUnit(w, h int, unit string, minx, miny, vw, vh int)
begin the SVG document with the width w, height h, in the specified unit, with a viewBox at minx, miny, vw, vh.
<http://www.w3.org/TR/SVG11/struct.html#SVGElement>
End()
end the SVG document
Script(scriptype string, data ...string)
Script defines a script with a specified type, (for example "application/javascript").
if the first variadic argument is a link, use only the link reference.
Otherwise, treat variadic arguments as the text of the script (marked up as CDATA).
if no data is specified, simply close the script element.
<http://www.w3.org/TR/SVG/script.html>
Style(scriptype string, data ...string)
Style defines a script with a specified type, (for example "text/css").
if the first variadic argument is a link, use only the link reference.
Otherwise, treat variadic arguments as the text of the script (marked up as CDATA).
if no data is specified, simply close the style element.
<https://www.w3.org/TR/SVG/styling.html#StyleElement>
Group(s ...string)
begin a group, with arbitrary attributes
<http://www.w3.org/TR/SVG11/struct.html#GElement>
Gstyle(s string)
begin a group, with the specified style.
<http://www.w3.org/TR/SVG11/struct.html#GElement>
Gid(s string)
begin a group, with the specified id.
Gtransform(s string)
begin a group, with the specified transform, end with Gend().
<http://www.w3.org/TR/SVG11/coords.html#TransformAttribute>
Translate(x, y int)
begins coordinate translation to (x,y), end with Gend().
<http://www.w3.org/TR/SVG11/coords.html#TransformAttribute>
Scale(n float64)
scales the coordinate system by n, end with Gend().
<http://www.w3.org/TR/SVG11/coords.html#TransformAttribute>
ScaleXY(x, y float64)
scales the coordinate system by x, y. End with Gend().
<http://www.w3.org/TR/SVG11/coords.html#TransformAttribute>
SkewX(a float64)
SkewX skews the x coordinate system by angle a, end with Gend().
<http://www.w3.org/TR/SVG11/coords.html#TransformAttribute>
SkewY(a float64)
SkewY skews the y coordinate system by angle a, end with Gend().
<http://www.w3.org/TR/SVG11/coords.html#TransformAttribute>
SkewXY(ax, ay float64)
SkewXY skews x and y coordinate systems by ax, ay respectively, end with Gend().
<http://www.w3.org/TR/SVG11/coords.html#TransformAttribute>
Rotate(r float64)
rotates the coordinate system by r degrees, end with Gend().
<http://www.w3.org/TR/SVG11/coords.html#TransformAttribute>
TranslateRotate(x, y int, r float64)
translates the coordinate system to (x,y), then rotates to r degrees, end with Gend().
RotateTranslate(x, y int, r float64)
rotates the coordinate system r degrees, then translates to (x,y), end with Gend().
Gend()
end the group (must be paired with Gstyle, Gtransform, Gid).
ClipPath(s ...string)
Begin a ClipPath
<http://www.w3.org/TR/SVG/masking.html#ClippingPaths>
ClipEnd()
End a ClipPath
<http://www.w3.org/TR/SVG/masking.html#ClippingPaths>
Def()
begin a definition block.
<http://www.w3.org/TR/SVG11/struct.html#DefsElement>
DefEnd()
end a definition block.
Marker(id string, x, y, w, h int, s ...string)
define a marker
<http://www.w3.org/TR/SVG11/painting.html#MarkerElement>
MarkerEnd()
end a marker
Mask(id string, x int, y int, w int, h int, s ...string)
creates a mask with a specified id, dimension, and optional style.
<http://www.w3.org/TR/SVG/masking.html>
MaskEnd()
ends the Mask element.
Pattern(id string, x, y, width, height int, putype string, s ...string)
define a Pattern with the specified dimensions, the putype can be either "user" or "obj", which sets the patternUnits
attribute to be either userSpaceOnUse or objectBoundingBox.
<http://www.w3.org/TR/SVG11/pservers.html#Patterns>
Desc(s string)
specify the text of the description.
<http://www.w3.org/TR/SVG11/struct.html#DescElement>
Title(s string)
specify the text of the title.
<http://www.w3.org/TR/SVG11/struct.html#TitleElement>
Link(href string, title string)
begin a link named "href", with the specified title.
<http://www.w3.org/TR/SVG11/linking.html#Links>
LinkEnd()
end the link.
Use(x int, y int, link string, s ...string)
place the object referenced at link at the location x, y.
<http://www.w3.org/TR/SVG11/struct.html#UseElement>
### Shapes ###
Circle(x int, y int, r int, s ...string)
draw a circle, centered at x,y with radius r.
<http://www.w3.org/TR/SVG11/shapes.html#CircleElement>
![Circle](http://farm5.static.flickr.com/4144/5187953823_01a1741489_m.jpg)
Ellipse(x int, y int, w int, h int, s ...string)
draw an ellipse, centered at x,y with radii w, and h.
<http://www.w3.org/TR/SVG11/shapes.html#EllipseElement>
![Ellipse](http://farm2.static.flickr.com/1271/5187953773_a9d1fc406c_m.jpg)
Polygon(x []int, y []int, s ...string)
draw a series of line segments using an array of x, y coordinates.
<http://www.w3.org/TR/SVG11/shapes.html#PolygonElement>
![Polygon](http://farm2.static.flickr.com/1006/5187953873_337dc26597_m.jpg)
Rect(x int, y int, w int, h int, s ...string)
draw a rectangle with upper left-hand corner at x,y, with width w, and height h.
<http://www.w3.org/TR/SVG11/shapes.html#RectElement>
![Rect](http://farm2.static.flickr.com/1233/5188556032_86c90e354b_m.jpg)
CenterRect(x int, y int, w int, h int, s ...string)
draw a rectangle with its center at x,y, with width w, and height h.
Roundrect(x int, y int, w int, h int, rx int, ry int, s ...string)
draw a rounded rectangle with upper the left-hand corner at x,y,
with width w, and height h. The radii for the rounded portion
is specified by rx (width), and ry (height).
![Roundrect](http://farm2.static.flickr.com/1275/5188556120_e2a9998fee_m.jpg)
Square(x int, y int, s int, style ...string)
draw a square with upper left corner at x,y with sides of length s.
![Square](http://farm5.static.flickr.com/4110/5187953659_54dcce242e_m.jpg)
### Paths ###
Path(p string, s ...style)
draw the arbitrary path as specified in p, according to the style specified in s. <http://www.w3.org/TR/SVG11/paths.html>
Arc(sx int, sy int, ax int, ay int, r int, large bool, sweep bool, ex int, ey int, s ...string)
draw an elliptical arc beginning coordinate at sx,sy, ending coordinate at ex, ey
width and height of the arc are specified by ax, ay, the x axis rotation is r
if sweep is true, then the arc will be drawn in a "positive-angle" direction (clockwise),
if false, the arc is drawn counterclockwise.
if large is true, the arc sweep angle is greater than or equal to 180 degrees,
otherwise the arc sweep is less than 180 degrees.
<http://www.w3.org/TR/SVG11/paths.html#PathDataEllipticalArcCommands>
![Arc](http://farm2.static.flickr.com/1300/5188556148_df1a176074_m.jpg)
Bezier(sx int, sy int, cx int, cy int, px int, py int, ex int, ey int, s ...string)
draw a cubic bezier curve, beginning at sx,sy, ending at ex,ey
with control points at cx,cy and px,py.
<http://www.w3.org/TR/SVG11/paths.html#PathDataCubicBezierCommands>
![Bezier](http://farm2.static.flickr.com/1233/5188556246_a03e67d013.jpg)
Qbezier(sx int, sy int, cx int, cy int, ex int, ey int, tx int, ty int, s ...string)
draw a quadratic bezier curve, beginning at sx, sy, ending at tx,ty
with control points are at cx,cy, ex,ey.
<http://www.w3.org/TR/SVG11/paths.html#PathDataQuadraticBezierCommands>
![Qbezier](http://farm2.static.flickr.com/1018/5187953917_9a43cf64fb.jpg)
Qbez(sx int, sy int, cx int, cy int, ex int, ey int, s...string)
draws a quadratic bezier curver, with optional style beginning at sx,sy, ending at ex, sy
with the control point at cx, cy.
<http://www.w3.org/TR/SVG11/paths.html#PathDataQuadraticBezierCommands>
![Qbez](http://farm6.static.flickr.com/5176/5569879349_5f726aab5e.jpg)
### Lines ###
Line(x1 int, y1 int, x2 int, y2 int, s ...string)
draw a line segment between x1,y1 and x2,y2.
<http://www.w3.org/TR/SVG11/shapes.html#LineElement>
![Line](http://farm5.static.flickr.com/4154/5188556080_0be19da0bc.jpg)
Polyline(x []int, y []int, s ...string)
draw a polygon using coordinates specified in x,y arrays.
<http://www.w3.org/TR/SVG11/shapes.html#PolylineElement>
![Polyline](http://farm2.static.flickr.com/1266/5188556384_a863273a69.jpg)
### Image and Text ###
Image(x int, y int, w int, h int, link string, s ...string)
place at x,y (upper left hand corner), the image with width w, and height h, referenced at link.
<http://www.w3.org/TR/SVG11/struct.html#ImageElement>
![Image](http://farm5.static.flickr.com/4058/5188556346_e5ce3dcbc2_m.jpg)
Text(x int, y int, t string, s ...string)
Place the specified text, t at x,y according to the style specified in s.
<http://www.w3.org/TR/SVG11/text.html#TextElement>
Textlines(x, y int, s []string, size, spacing int, fill, align string)
Places lines of text in s, starting at x,y, at the specified size, fill, and alignment, and spacing.
Textpath(t string, pathid string, s ...string)
places optionally styled text along a previously defined path.
<http://www.w3.org/TR/SVG11/text.html#TextPathElement>
![Image](http://farm4.static.flickr.com/3149/5694580737_4b291df768_m.jpg)
### Color ###
RGB(r int, g int, b int) string
creates a style string for the fill color designated
by the (r)ed, g(reen), (b)lue components.
<http://www.w3.org/TR/css3-color/>
RGBA(r int, g int, b int, a float64) string
as above, but includes the color's opacity as a value
between 0.0 (fully transparent) and 1.0 (opaque).
### Gradients ###
LinearGradient(id string, x1, y1, x2, y2 uint8, sc []Offcolor)
constructs a linear color gradient identified by id,
along the vector defined by (x1,y1), and (x2,y2).
The stop color sequence defined in sc. Coordinates are expressed as percentages.
<http://www.w3.org/TR/SVG11/pservers.html#LinearGradients>
![LinearGradient](http://farm5.static.flickr.com/4153/5187954033_3972f63fa9.jpg)
RadialGradient(id string, cx, cy, r, fx, fy uint8, sc []Offcolor)
constructs a radial color gradient identified by id,
centered at (cx,cy), with a radius of r.
(fx, fy) define the location of the focal point of the light source.
The stop color sequence defined in sc.
Coordinates are expressed as percentages.
<http://www.w3.org/TR/SVG11/pservers.html#RadialGradients>
![RadialGradient](http://farm2.static.flickr.com/1302/5187954065_7ddba7b819.jpg)
### Filter Effects ###
Filter(id string, s ...string)
Filter begins a filter set
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#FilterElement>
Fend()
Fend ends a filter set
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#FilterElement>
FeBlend(fs Filterspec, mode string, s ...string)
FeBlend specifies a Blend filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feBlendElement>
FeColorMatrix(fs Filterspec, values [20]float64, s ...string)
FeColorMatrix specifies a color matrix filter primitive, with matrix values
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feColorMatrixElement>
FeColorMatrixHue(fs Filterspec, value float64, s ...string)
FeColorMatrix specifies a color matrix filter primitive, with hue values
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feColorMatrixElement>
FeColorMatrixSaturate(fs Filterspec, value float64, s ...string)
FeColorMatrix specifies a color matrix filter primitive, with saturation values
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feColorMatrixElement>
FeColorMatrixLuminence(fs Filterspec, s ...string)
FeColorMatrix specifies a color matrix filter primitive, with luminence values
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feColorMatrixElement>
FeComponentTransfer()
FeComponentTransfer begins a feComponent filter Element>
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement>
FeCompEnd()
FeCompEnd ends a feComponent filter Element>
FeComposite(fs Filterspec, operator string, k1, k2, k3, k4 int, s ...string)
FeComposite specifies a feComposite filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feCompositeElement>
FeConvolveMatrix(fs Filterspec, matrix [9]int, s ...string)
FeConvolveMatrix specifies a feConvolveMatrix filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feConvolveMatrixElement>
FeDiffuseLighting(fs Filterspec, scale, constant float64, s ...string)
FeDiffuseLighting specifies a diffuse lighting filter primitive,
a container for light source Element>s, end with DiffuseEnd()
FeDiffEnd()
FeDiffuseEnd ends a diffuse lighting filter primitive container
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feDiffuseLightingElement>
FeDisplacementMap(fs Filterspec, scale float64, xchannel, ychannel string, s ...string)
FeDisplacementMap specifies a feDisplacementMap filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feDisplacementMapElement>
FeDistantLight(fs Filterspec, azimuth, elevation float64, s ...string)
FeDistantLight specifies a feDistantLight filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feDistantLightElement>
FeFlood(fs Filterspec, color string, opacity float64, s ...string)
FeFlood specifies a flood filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feFloodElement>
FeFuncLinear(channel string, slope, intercept float64)
FeFuncLinear is the linear form of feFunc
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement>
FeFuncGamma(channel, amplitude, exponent, offset float64)
FeFuncGamma is the gamma curve form of feFunc
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement>
FeFuncTable(channel string, tv []float64)
FeFuncGamma is the form of feFunc using a table of values
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement>
FeFuncDiscrete(channel string, tv []float64)
FeFuncGamma is the form of feFunc using discrete values
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement>
FeGaussianBlur(fs Filterspec, stdx, stdy float64, s ...string)
FeGaussianBlur specifies a Gaussian Blur filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feGaussianBlurElement>
FeImage(href string, result string, s ...string)
FeImage specifies a feImage filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feImageElement>
FeMerge(nodes []string, s ...string)
FeMerge specifies a feMerge filter primitive, containing feMerge Element>s
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feMergeElement>
FeMorphology(fs Filterspec, operator string, xradius, yradius float64, s ...string)
FeMorphologyLight specifies a feMorphologyLight filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feMorphologyElement>
FeOffset(fs Filterspec, dx, dy int, s ...string)
FeOffset specifies the feOffset filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feOffsetElement>
FePointLight(x, y, z float64, s ...string)
FePointLight specifies a fePpointLight filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#fePointLightElement>
FeSpecularLighting(fs Filterspec, scale, constant float64, exponent int, color string, s ...string)
FeSpecularLighting specifies a specular lighting filter primitive,
a container for light source elements, end with SpecularEnd()
FeSpecEnd()
FeSpecularEnd ends a specular lighting filter primitive container
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feSpecularLightingElement>
FeSpotLight(fs Filterspec, x, y, z, px, py, pz float64, s ...string)
FeSpotLight specifies a feSpotLight filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feSpotLightElement>
FeTile(fs Filterspec, in string, s ...string)
FeTile specifies the tile utility filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feTileElement>
FeTurbulence(fs Filterspec, ftype string, bfx, bfy float64, octaves int, seed int64, stitch bool, s ...string)
FeTurbulence specifies a turbulence filter primitive
Standard reference: <http://www.w3.org/TR/SVG11/filters.html#feTurbulenceElement>
### Filter convenience functions (modeled on CSS filter effects) ###
Blur(p float64)
Blur function by standard deviation
Brightness(p float64)
Brightness function (0-100)
Grayscale()
Apply a grayscale filter to the image
HueRotate(a float64)
Rotate Hues (0-360 degrees)
Invert()
Invert the image's colors
Saturate(p float64)
Percent saturation, 0 is grayscale
Sepia()
Apply sepia tone
### Utility ###
Grid(x int, y int, w int, h int, n int, s ...string)
draws a grid of straight lines starting at x,y, with a width w, and height h, and a size of n.
![Grid](http://farm5.static.flickr.com/4133/5190957924_7a31d0db34.jpg)
### Credits ###
Thanks to Jonathan Wright for the io.Writer update.

126
vendor/github.com/ajstarks/svgo/doc.go generated vendored Normal file
View File

@@ -0,0 +1,126 @@
/*
Package svg generates SVG as defined by the Scalable Vector Graphics 1.1 Specification (<http://www.w3.org/TR/SVG11/>).
Output goes to the specified io.Writer.
Supported SVG elements and functions
Shapes, lines, text
circle, ellipse, polygon, polyline, rect (including roundrects), line, text
Paths
general, arc, cubic and quadratic bezier paths,
Image and Gradients
image, linearGradient, radialGradient,
Transforms
translate, rotate, scale, skewX, skewY
Filter Effects
filter, feBlend, feColorMatrix, feColorMatrix, feComponentTransfer, feComposite, feConvolveMatrix, feDiffuseLighting,
feDisplacementMap, feDistantLight, feFlood, feGaussianBlur, feImage, feMerge, feMorphology, feOffset, fePointLight,
feSpecularLighting, feSpotLight,feTile, feTurbulence
Metadata elements
desc, defs, g (style, transform, id), mask, marker, pattern, title, (a)ddress, link, script, style, use
Usage: (assuming GOPATH is set)
go get github.com/ajstarks/svgo
go install github.com/ajstarks/svgo/...
You can use godoc to browse the documentation from the command line:
$ godoc github.com/ajstarks/svgo
a minimal program, to generate SVG to standard output.
package main
import (
"github.com/ajstarks/svgo"
"os"
)
func main() {
width := 500
height := 500
canvas := svg.New(os.Stdout)
canvas.Start(width, height)
canvas.Circle(width/2, height/2, 100)
canvas.Text(width/2, height/2, "Hello, SVG", "text-anchor:middle;font-size:30px;fill:white")
canvas.End()
}
Drawing in a web server: (http://localhost:2003/circle)
package main
import (
"log"
"github.com/ajstarks/svgo"
"net/http"
)
func main() {
http.Handle("/circle", http.HandlerFunc(circle))
err := http.ListenAndServe(":2003", nil)
if err != nil {
log.Fatal("ListenAndServe:", err)
}
}
func circle(w http.ResponseWriter, req *http.Request) {
w.Header().Set("Content-Type", "image/svg+xml")
s := svg.New(w)
s.Start(500, 500)
s.Circle(250, 250, 125, "fill:none;stroke:black")
s.End()
}
Functions and types
Many functions use x, y to specify an object's location, and w, h to specify the object's width and height.
Where applicable, a final optional argument specifies the style to be applied to the object.
The style strings follow the SVG standard; name:value pairs delimited by semicolons, or a
series of name="value" pairs. For example: `"fill:none; opacity:0.3"` or `fill="none" opacity="0.3"` (see: <http://www.w3.org/TR/SVG11/styling.html>)
The SVG type:
type SVG struct {
Writer io.Writer
}
Most operations are methods on this type, specifying the destination io.Writer.
The Offcolor type:
type Offcolor struct {
Offset uint8
Color string
Opacity float64
}
is used to specify the offset, color, and opacity of stop colors in linear and radial gradients
The Filterspec type:
type Filterspec struct {
In string
In2 string
Result string
}
is used to specify inputs and results for filter effects
*/
package svg

BIN
vendor/github.com/ajstarks/svgo/gophercolor128x128.png generated vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB

39
vendor/github.com/ajstarks/svgo/newsvg generated vendored Normal file
View File

@@ -0,0 +1,39 @@
#!/bin/sh
if test $# -lt 1
then
echo "specify a file"
exit 2
fi
if test ! -f $1
then
cat <<! > $1
package main
import (
"github.com/ajstarks/svgo"
"os"
)
var (
width = 500
height = 500
canvas = svg.New(os.Stdout)
)
func background(v int) { canvas.Rect(0, 0, width, height, canvas.RGB(v, v, v)) }
func main() {
canvas.Start(width, height)
background(255)
// your code here
canvas.Grid(0, 0, width, height, 10, "stroke:black;opacity:0.1")
canvas.End()
}
!
fi
$EDITOR $1

989
vendor/github.com/ajstarks/svgo/svg.go generated vendored Normal file
View File

@@ -0,0 +1,989 @@
// Package svg provides an API for generating Scalable Vector Graphics (SVG)
package svg
// package main
//
// import (
// "github.com/ajstarks/svgo"
// "os"
// )
//
// var (
// width = 500
// height = 500
// canvas = svg.New(os.Stdout)
// )
//
// func main() {
// canvas.Start(width, height)
// canvas.Circle(width/2, height/2, 100)
// canvas.Text(width/2, height/2, "Hello, SVG",
// "text-anchor:middle;font-size:30px;fill:white")
// canvas.End()
// }
//
import (
"fmt"
"io"
"encoding/xml"
"strings"
)
// SVG defines the location of the generated SVG
type SVG struct {
Writer io.Writer
}
// Offcolor defines the offset and color for gradients
type Offcolor struct {
Offset uint8
Color string
Opacity float64
}
// Filterspec defines the specification of SVG filters
type Filterspec struct {
In, In2, Result string
}
const (
svgtop = `<?xml version="1.0"?>
<!-- Generated by SVGo -->
<svg`
svginitfmt = `%s width="%d%s" height="%d%s"`
svgns = `
xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink">`
vbfmt = `viewBox="%d %d %d %d"`
emptyclose = "/>\n"
)
// New is the SVG constructor, specifying the io.Writer where the generated SVG is written.
func New(w io.Writer) *SVG { return &SVG{w} }
func (svg *SVG) print(a ...interface{}) (n int, errno error) {
return fmt.Fprint(svg.Writer, a...)
}
func (svg *SVG) println(a ...interface{}) (n int, errno error) {
return fmt.Fprintln(svg.Writer, a...)
}
func (svg *SVG) printf(format string, a ...interface{}) (n int, errno error) {
return fmt.Fprintf(svg.Writer, format, a...)
}
func (svg *SVG) genattr(ns []string) {
for _, v := range ns {
svg.printf("\n %s", v)
}
svg.println(svgns)
}
// Structure, Metadata, Scripting, Style, Transformation, and Links
// Start begins the SVG document with the width w and height h.
// Other attributes may be optionally added, for example viewbox or additional namespaces
// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#SVGElement
func (svg *SVG) Start(w int, h int, ns ...string) {
svg.printf(svginitfmt, svgtop, w, "", h, "")
svg.genattr(ns)
}
// Startunit begins the SVG document, with width and height in the specified units
// Other attributes may be optionally added, for example viewbox or additional namespaces
func (svg *SVG) Startunit(w int, h int, unit string, ns ...string) {
svg.printf(svginitfmt, svgtop, w, unit, h, unit)
svg.genattr(ns)
}
// Startpercent begins the SVG document, with width and height as percentages
// Other attributes may be optionally added, for example viewbox or additional namespaces
func (svg *SVG) Startpercent(w int, h int, ns ...string) {
svg.printf(svginitfmt, svgtop, w, "%", h, "%")
svg.genattr(ns)
}
// Startview begins the SVG document, with the specified width, height, and viewbox
// Other attributes may be optionally added, for example viewbox or additional namespaces
func (svg *SVG) Startview(w, h, minx, miny, vw, vh int) {
svg.Start(w, h, fmt.Sprintf(vbfmt, minx, miny, vw, vh))
}
func (svg *SVG) StartviewUnit(w, h int, unit string, minx, miny, vw, vh int) {
svg.Startunit(w, h, unit, fmt.Sprintf(vbfmt, minx, miny, vw, vh))
}
// Startraw begins the SVG document, passing arbitrary attributes
func (svg *SVG) Startraw(ns ...string) {
svg.printf(svgtop)
svg.genattr(ns)
}
// End the SVG document
func (svg *SVG) End() { svg.println("</svg>") }
// linkembed defines an element with a specified type,
// (for example "application/javascript", or "text/css").
// if the first variadic argument is a link, use only the link reference.
// Otherwise, treat those arguments as the text of the script (marked up as CDATA).
// if no data is specified, just close the element
func (svg *SVG) linkembed(tag string, scriptype string, data ...string) {
svg.printf(`<%s type="%s"`, tag, scriptype)
switch {
case len(data) == 1 && islink(data[0]):
svg.printf(" %s/>\n", href(data[0]))
case len(data) > 0:
svg.printf(">\n<![CDATA[\n")
for _, v := range data {
svg.println(v)
}
svg.printf("]]>\n</%s>\n", tag)
default:
svg.println(`/>`)
}
}
// Script defines a script with a specified type, (for example "application/javascript").
func (svg *SVG) Script(scriptype string, data ...string) {
svg.linkembed("script", scriptype, data...)
}
// Style defines the specified style (for example "text/css")
func (svg *SVG) Style(scriptype string, data ...string) {
svg.linkembed("style", scriptype, data...)
}
// Gstyle begins a group, with the specified style.
// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#GElement
func (svg *SVG) Gstyle(s string) { svg.println(group("style", s)) }
// Gtransform begins a group, with the specified transform
// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute
func (svg *SVG) Gtransform(s string) { svg.println(group("transform", s)) }
// Translate begins coordinate translation, end with Gend()
// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute
func (svg *SVG) Translate(x, y int) { svg.Gtransform(translate(x, y)) }
// Scale scales the coordinate system by n, end with Gend()
// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute
func (svg *SVG) Scale(n float64) { svg.Gtransform(scale(n)) }
// ScaleXY scales the coordinate system by dx and dy, end with Gend()
// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute
func (svg *SVG) ScaleXY(dx, dy float64) { svg.Gtransform(scaleXY(dx, dy)) }
// SkewX skews the x coordinate system by angle a, end with Gend()
// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute
func (svg *SVG) SkewX(a float64) { svg.Gtransform(skewX(a)) }
// SkewY skews the y coordinate system by angle a, end with Gend()
// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute
func (svg *SVG) SkewY(a float64) { svg.Gtransform(skewY(a)) }
// SkewXY skews x and y coordinates by ax, ay respectively, end with Gend()
// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute
func (svg *SVG) SkewXY(ax, ay float64) { svg.Gtransform(skewX(ax) + " " + skewY(ay)) }
// Rotate rotates the coordinate system by r degrees, end with Gend()
// Standard Reference: http://www.w3.org/TR/SVG11/coords.html#TransformAttribute
func (svg *SVG) Rotate(r float64) { svg.Gtransform(rotate(r)) }
// TranslateRotate translates the coordinate system to (x,y), then rotates to r degrees, end with Gend()
func (svg *SVG) TranslateRotate(x, y int, r float64) {
svg.Gtransform(translate(x, y) + " " + rotate(r))
}
// RotateTranslate rotates the coordinate system r degrees, then translates to (x,y), end with Gend()
func (svg *SVG) RotateTranslate(x, y int, r float64) {
svg.Gtransform(rotate(r) + " " + translate(x, y))
}
// Group begins a group with arbitrary attributes
func (svg *SVG) Group(s ...string) { svg.printf("<g %s\n", endstyle(s, `>`)) }
// Gid begins a group, with the specified id
func (svg *SVG) Gid(s string) {
svg.print(`<g id="`)
xml.Escape(svg.Writer, []byte(s))
svg.println(`">`)
}
// Gend ends a group (must be paired with Gsttyle, Gtransform, Gid).
func (svg *SVG) Gend() { svg.println(`</g>`) }
// ClipPath defines a clip path
func (svg *SVG) ClipPath(s ...string) { svg.printf(`<clipPath %s`, endstyle(s, `>`)) }
// ClipEnd ends a ClipPath
func (svg *SVG) ClipEnd() {
svg.println(`</clipPath>`)
}
// Def begins a defintion block.
// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#DefsElement
func (svg *SVG) Def() { svg.println(`<defs>`) }
// DefEnd ends a defintion block.
func (svg *SVG) DefEnd() { svg.println(`</defs>`) }
// Marker defines a marker
// Standard reference: http://www.w3.org/TR/SVG11/painting.html#MarkerElement
func (svg *SVG) Marker(id string, x, y, width, height int, s ...string) {
svg.printf(`<marker id="%s" refX="%d" refY="%d" markerWidth="%d" markerHeight="%d" %s`,
id, x, y, width, height, endstyle(s, ">\n"))
}
// MarkEnd ends a marker
func (svg *SVG) MarkerEnd() { svg.println(`</marker>`) }
// Pattern defines a pattern with the specified dimensions.
// The putype can be either "user" or "obj", which sets the patternUnits
// attribute to be either userSpaceOnUse or objectBoundingBox
// Standard reference: http://www.w3.org/TR/SVG11/pservers.html#Patterns
func (svg *SVG) Pattern(id string, x, y, width, height int, putype string, s ...string) {
puattr := "userSpaceOnUse"
if putype != "user" {
puattr = "objectBoundingBox"
}
svg.printf(`<pattern id="%s" x="%d" y="%d" width="%d" height="%d" patternUnits="%s" %s`,
id, x, y, width, height, puattr, endstyle(s, ">\n"))
}
// PatternEnd ends a marker
func (svg *SVG) PatternEnd() { svg.println(`</pattern>`) }
// Desc specified the text of the description tag.
// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#DescElement
func (svg *SVG) Desc(s string) { svg.tt("desc", s) }
// Title specified the text of the title tag.
// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#TitleElement
func (svg *SVG) Title(s string) { svg.tt("title", s) }
// Link begins a link named "name", with the specified title.
// Standard Reference: http://www.w3.org/TR/SVG11/linking.html#Links
func (svg *SVG) Link(href string, title string) {
svg.printf("<a xlink:href=\"%s\" xlink:title=\"", href)
xml.Escape(svg.Writer, []byte(title))
svg.println("\">")
}
// LinkEnd ends a link.
func (svg *SVG) LinkEnd() { svg.println(`</a>`) }
// Use places the object referenced at link at the location x, y, with optional style.
// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#UseElement
func (svg *SVG) Use(x int, y int, link string, s ...string) {
svg.printf(`<use %s %s %s`, loc(x, y), href(link), endstyle(s, emptyclose))
}
// Mask creates a mask with a specified id, dimension, and optional style.
func (svg *SVG) Mask(id string, x int, y int, w int, h int, s ...string) {
svg.printf(`<mask id="%s" x="%d" y="%d" width="%d" height="%d" %s`, id, x, y, w, h, endstyle(s, `>`))
}
// MaskEnd ends a Mask.
func (svg *SVG) MaskEnd() { svg.println(`</mask>`) }
// Shapes
// Circle centered at x,y, with radius r, with optional style.
// Standard Reference: http://www.w3.org/TR/SVG11/shapes.html#CircleElement
func (svg *SVG) Circle(x int, y int, r int, s ...string) {
svg.printf(`<circle cx="%d" cy="%d" r="%d" %s`, x, y, r, endstyle(s, emptyclose))
}
// Ellipse centered at x,y, centered at x,y with radii w, and h, with optional style.
// Standard Reference: http://www.w3.org/TR/SVG11/shapes.html#EllipseElement
func (svg *SVG) Ellipse(x int, y int, w int, h int, s ...string) {
svg.printf(`<ellipse cx="%d" cy="%d" rx="%d" ry="%d" %s`,
x, y, w, h, endstyle(s, emptyclose))
}
// Polygon draws a series of line segments using an array of x, y coordinates, with optional style.
// Standard Reference: http://www.w3.org/TR/SVG11/shapes.html#PolygonElement
func (svg *SVG) Polygon(x []int, y []int, s ...string) {
svg.poly(x, y, "polygon", s...)
}
// Rect draws a rectangle with upper left-hand corner at x,y, with width w, and height h, with optional style
// Standard Reference: http://www.w3.org/TR/SVG11/shapes.html#RectElement
func (svg *SVG) Rect(x int, y int, w int, h int, s ...string) {
svg.printf(`<rect %s %s`, dim(x, y, w, h), endstyle(s, emptyclose))
}
// CenterRect draws a rectangle with its center at x,y, with width w, and height h, with optional style
func (svg *SVG) CenterRect(x int, y int, w int, h int, s ...string) {
svg.Rect(x-(w/2), y-(h/2), w, h, s...)
}
// Roundrect draws a rounded rectangle with upper the left-hand corner at x,y,
// with width w, and height h. The radii for the rounded portion
// are specified by rx (width), and ry (height).
// Style is optional.
// Standard Reference: http://www.w3.org/TR/SVG11/shapes.html#RectElement
func (svg *SVG) Roundrect(x int, y int, w int, h int, rx int, ry int, s ...string) {
svg.printf(`<rect %s rx="%d" ry="%d" %s`, dim(x, y, w, h), rx, ry, endstyle(s, emptyclose))
}
// Square draws a square with upper left corner at x,y with sides of length l, with optional style.
func (svg *SVG) Square(x int, y int, l int, s ...string) {
svg.Rect(x, y, l, l, s...)
}
// Paths
// Path draws an arbitrary path, the caller is responsible for structuring the path data
func (svg *SVG) Path(d string, s ...string) {
svg.printf(`<path d="%s" %s`, d, endstyle(s, emptyclose))
}
// Arc draws an elliptical arc, with optional style, beginning coordinate at sx,sy, ending coordinate at ex, ey
// width and height of the arc are specified by ax, ay, the x axis rotation is r
// if sweep is true, then the arc will be drawn in a "positive-angle" direction (clockwise), if false,
// the arc is drawn counterclockwise.
// if large is true, the arc sweep angle is greater than or equal to 180 degrees,
// otherwise the arc sweep is less than 180 degrees
// http://www.w3.org/TR/SVG11/paths.html#PathDataEllipticalArcCommands
func (svg *SVG) Arc(sx int, sy int, ax int, ay int, r int, large bool, sweep bool, ex int, ey int, s ...string) {
svg.printf(`%s A%s %d %s %s %s" %s`,
ptag(sx, sy), coord(ax, ay), r, onezero(large), onezero(sweep), coord(ex, ey), endstyle(s, emptyclose))
}
// Bezier draws a cubic bezier curve, with optional style, beginning at sx,sy, ending at ex,ey
// with control points at cx,cy and px,py.
// Standard Reference: http://www.w3.org/TR/SVG11/paths.html#PathDataCubicBezierCommands
func (svg *SVG) Bezier(sx int, sy int, cx int, cy int, px int, py int, ex int, ey int, s ...string) {
svg.printf(`%s C%s %s %s" %s`,
ptag(sx, sy), coord(cx, cy), coord(px, py), coord(ex, ey), endstyle(s, emptyclose))
}
// Qbez draws a quadratic bezier curver, with optional style
// beginning at sx,sy, ending at ex, sy with control points at cx, cy
// Standard Reference: http://www.w3.org/TR/SVG11/paths.html#PathDataQuadraticBezierCommands
func (svg *SVG) Qbez(sx int, sy int, cx int, cy int, ex int, ey int, s ...string) {
svg.printf(`%s Q%s %s" %s`,
ptag(sx, sy), coord(cx, cy), coord(ex, ey), endstyle(s, emptyclose))
}
// Qbezier draws a Quadratic Bezier curve, with optional style, beginning at sx, sy, ending at tx,ty
// with control points are at cx,cy, ex,ey.
// Standard Reference: http://www.w3.org/TR/SVG11/paths.html#PathDataQuadraticBezierCommands
func (svg *SVG) Qbezier(sx int, sy int, cx int, cy int, ex int, ey int, tx int, ty int, s ...string) {
svg.printf(`%s Q%s %s T%s" %s`,
ptag(sx, sy), coord(cx, cy), coord(ex, ey), coord(tx, ty), endstyle(s, emptyclose))
}
// Lines
// Line draws a straight line between two points, with optional style.
// Standard Reference: http://www.w3.org/TR/SVG11/shapes.html#LineElement
func (svg *SVG) Line(x1 int, y1 int, x2 int, y2 int, s ...string) {
svg.printf(`<line x1="%d" y1="%d" x2="%d" y2="%d" %s`, x1, y1, x2, y2, endstyle(s, emptyclose))
}
// Polyline draws connected lines between coordinates, with optional style.
// Standard Reference: http://www.w3.org/TR/SVG11/shapes.html#PolylineElement
func (svg *SVG) Polyline(x []int, y []int, s ...string) {
svg.poly(x, y, "polyline", s...)
}
// Image places at x,y (upper left hand corner), the image with
// width w, and height h, referenced at link, with optional style.
// Standard Reference: http://www.w3.org/TR/SVG11/struct.html#ImageElement
func (svg *SVG) Image(x int, y int, w int, h int, link string, s ...string) {
svg.printf(`<image %s %s %s`, dim(x, y, w, h), href(link), endstyle(s, emptyclose))
}
// Text places the specified text, t at x,y according to the style specified in s
// Standard Reference: http://www.w3.org/TR/SVG11/text.html#TextElement
func (svg *SVG) Text(x int, y int, t string, s ...string) {
svg.printf(`<text %s %s`, loc(x, y), endstyle(s, ">"))
xml.Escape(svg.Writer, []byte(t))
svg.println(`</text>`)
}
// Textpath places text optionally styled text along a previously defined path
// Standard Reference: http://www.w3.org/TR/SVG11/text.html#TextPathElement
func (svg *SVG) Textpath(t string, pathid string, s ...string) {
svg.printf("<text %s<textPath xlink:href=\"%s\">", endstyle(s, ">"), pathid)
xml.Escape(svg.Writer, []byte(t))
svg.println(`</textPath></text>`)
}
// Textlines places a series of lines of text starting at x,y, at the specified size, fill, and alignment.
// Each line is spaced according to the spacing argument
func (svg *SVG) Textlines(x, y int, s []string, size, spacing int, fill, align string) {
svg.Gstyle(fmt.Sprintf("font-size:%dpx;fill:%s;text-anchor:%s", size, fill, align))
for _, t := range s {
svg.Text(x, y, t)
y += spacing
}
svg.Gend()
}
// Colors
// RGB specifies a fill color in terms of a (r)ed, (g)reen, (b)lue triple.
// Standard reference: http://www.w3.org/TR/css3-color/
func (svg *SVG) RGB(r int, g int, b int) string {
return fmt.Sprintf(`fill:rgb(%d,%d,%d)`, r, g, b)
}
// RGBA specifies a fill color in terms of a (r)ed, (g)reen, (b)lue triple and opacity.
func (svg *SVG) RGBA(r int, g int, b int, a float64) string {
return fmt.Sprintf(`fill-opacity:%.2f; %s`, a, svg.RGB(r, g, b))
}
// Gradients
// LinearGradient constructs a linear color gradient identified by id,
// along the vector defined by (x1,y1), and (x2,y2).
// The stop color sequence defined in sc. Coordinates are expressed as percentages.
func (svg *SVG) LinearGradient(id string, x1, y1, x2, y2 uint8, sc []Offcolor) {
svg.printf("<linearGradient id=\"%s\" x1=\"%d%%\" y1=\"%d%%\" x2=\"%d%%\" y2=\"%d%%\">\n",
id, pct(x1), pct(y1), pct(x2), pct(y2))
svg.stopcolor(sc)
svg.println("</linearGradient>")
}
// RadialGradient constructs a radial color gradient identified by id,
// centered at (cx,cy), with a radius of r.
// (fx, fy) define the location of the focal point of the light source.
// The stop color sequence defined in sc.
// Coordinates are expressed as percentages.
func (svg *SVG) RadialGradient(id string, cx, cy, r, fx, fy uint8, sc []Offcolor) {
svg.printf("<radialGradient id=\"%s\" cx=\"%d%%\" cy=\"%d%%\" r=\"%d%%\" fx=\"%d%%\" fy=\"%d%%\">\n",
id, pct(cx), pct(cy), pct(r), pct(fx), pct(fy))
svg.stopcolor(sc)
svg.println("</radialGradient>")
}
// stopcolor is a utility function used by the gradient functions
// to define a sequence of offsets (expressed as percentages) and colors
func (svg *SVG) stopcolor(oc []Offcolor) {
for _, v := range oc {
svg.printf("<stop offset=\"%d%%\" stop-color=\"%s\" stop-opacity=\"%.2f\"/>\n",
pct(v.Offset), v.Color, v.Opacity)
}
}
// Filter Effects:
// Most functions have common attributes (in, in2, result) defined in type Filterspec
// used as a common first argument.
// Filter begins a filter set
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#FilterElement
func (svg *SVG) Filter(id string, s ...string) {
svg.printf(`<filter id="%s" %s`, id, endstyle(s, ">\n"))
}
// Fend ends a filter set
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#FilterElement
func (svg *SVG) Fend() {
svg.println(`</filter>`)
}
// FeBlend specifies a Blend filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feBlendElement
func (svg *SVG) FeBlend(fs Filterspec, mode string, s ...string) {
switch mode {
case "normal", "multiply", "screen", "darken", "lighten":
break
default:
mode = "normal"
}
svg.printf(`<feBlend %s mode="%s" %s`,
fsattr(fs), mode, endstyle(s, emptyclose))
}
// FeColorMatrix specifies a color matrix filter primitive, with matrix values
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feColorMatrixElement
func (svg *SVG) FeColorMatrix(fs Filterspec, values [20]float64, s ...string) {
svg.printf(`<feColorMatrix %s type="matrix" values="`, fsattr(fs))
for _, v := range values {
svg.printf(`%g `, v)
}
svg.printf(`" %s`, endstyle(s, emptyclose))
}
// FeColorMatrixHue specifies a color matrix filter primitive, with hue rotation values
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feColorMatrixElement
func (svg *SVG) FeColorMatrixHue(fs Filterspec, value float64, s ...string) {
if value < -360 || value > 360 {
value = 0
}
svg.printf(`<feColorMatrix %s type="hueRotate" values="%g" %s`,
fsattr(fs), value, endstyle(s, emptyclose))
}
// FeColorMatrixSaturate specifies a color matrix filter primitive, with saturation values
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feColorMatrixElement
func (svg *SVG) FeColorMatrixSaturate(fs Filterspec, value float64, s ...string) {
if value < 0 || value > 1 {
value = 1
}
svg.printf(`<feColorMatrix %s type="saturate" values="%g" %s`,
fsattr(fs), value, endstyle(s, emptyclose))
}
// FeColorMatrixLuminence specifies a color matrix filter primitive, with luminence values
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feColorMatrixElement
func (svg *SVG) FeColorMatrixLuminence(fs Filterspec, s ...string) {
svg.printf(`<feColorMatrix %s type="luminenceToAlpha" %s`,
fsattr(fs), endstyle(s, emptyclose))
}
// FeComponentTransfer begins a feComponent filter element
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
func (svg *SVG) FeComponentTransfer() {
svg.println(`<feComponentTransfer>`)
}
// FeCompEnd ends a feComponent filter element
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
func (svg *SVG) FeCompEnd() {
svg.println(`</feComponentTransfer>`)
}
// FeComposite specifies a feComposite filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feCompositeElement
func (svg *SVG) FeComposite(fs Filterspec, operator string, k1, k2, k3, k4 int, s ...string) {
switch operator {
case "over", "in", "out", "atop", "xor", "arithmetic":
break
default:
operator = "over"
}
svg.printf(`<feComposite %s operator="%s" k1="%d" k2="%d" k3="%d" k4="%d" %s`,
fsattr(fs), operator, k1, k2, k3, k4, endstyle(s, emptyclose))
}
// FeConvolveMatrix specifies a feConvolveMatrix filter primitive
// Standard referencd: http://www.w3.org/TR/SVG11/filters.html#feConvolveMatrixElement
func (svg *SVG) FeConvolveMatrix(fs Filterspec, matrix [9]int, s ...string) {
svg.printf(`<feConvolveMatrix %s kernelMatrix="%d %d %d %d %d %d %d %d %d" %s`,
fsattr(fs),
matrix[0], matrix[1], matrix[2],
matrix[3], matrix[4], matrix[5],
matrix[6], matrix[7], matrix[8], endstyle(s, emptyclose))
}
// FeDiffuseLighting specifies a diffuse lighting filter primitive,
// a container for light source elements, end with DiffuseEnd()
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
func (svg *SVG) FeDiffuseLighting(fs Filterspec, scale, constant float64, s ...string) {
svg.printf(`<feDiffuseLighting %s surfaceScale="%g" diffuseConstant="%g" %s`,
fsattr(fs), scale, constant, endstyle(s, `>`))
}
// FeDiffEnd ends a diffuse lighting filter primitive container
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feDiffuseLightingElement
func (svg *SVG) FeDiffEnd() {
svg.println(`</feDiffuseLighting>`)
}
// FeDisplacementMap specifies a feDisplacementMap filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feDisplacementMapElement
func (svg *SVG) FeDisplacementMap(fs Filterspec, scale float64, xchannel, ychannel string, s ...string) {
svg.printf(`<feDisplacementMap %s scale="%g" xChannelSelector="%s" yChannelSelector="%s" %s`,
fsattr(fs), scale, imgchannel(xchannel), ychannel, endstyle(s, emptyclose))
}
// FeDistantLight specifies a feDistantLight filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feDistantLightElement
func (svg *SVG) FeDistantLight(fs Filterspec, azimuth, elevation float64, s ...string) {
svg.printf(`<feDistantLight %s azimuth="%g" elevation="%g" %s`,
fsattr(fs), azimuth, elevation, endstyle(s, emptyclose))
}
// FeFlood specifies a flood filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feFloodElement
func (svg *SVG) FeFlood(fs Filterspec, color string, opacity float64, s ...string) {
svg.printf(`<feFlood %s flood-fill-color="%s" flood-fill-opacity="%g" %s`,
fsattr(fs), color, opacity, endstyle(s, emptyclose))
}
// FeFunc{linear|Gamma|Table|Discrete} specify various types of feFunc{R|G|B|A} filter primitives
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
// FeFuncLinear specifies a linear style function for the feFunc{R|G|B|A} filter element
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
func (svg *SVG) FeFuncLinear(channel string, slope, intercept float64) {
svg.printf(`<feFunc%s type="linear" slope="%g" intercept="%g"%s`,
imgchannel(channel), slope, intercept, emptyclose)
}
// FeFuncGamma specifies the curve values for gamma correction for the feFunc{R|G|B|A} filter element
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
func (svg *SVG) FeFuncGamma(channel string, amplitude, exponent, offset float64) {
svg.printf(`<feFunc%s type="gamma" amplitude="%g" exponent="%g" offset="%g"%s`,
imgchannel(channel), amplitude, exponent, offset, emptyclose)
}
// FeFuncTable specifies the table of values for the feFunc{R|G|B|A} filter element
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
func (svg *SVG) FeFuncTable(channel string, tv []float64) {
svg.printf(`<feFunc%s type="table"`, imgchannel(channel))
svg.tablevalues(`tableValues`, tv)
}
// FeFuncDiscrete specifies the discrete values for the feFunc{R|G|B|A} filter element
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feComponentTransferElement
func (svg *SVG) FeFuncDiscrete(channel string, tv []float64) {
svg.printf(`<feFunc%s type="discrete"`, imgchannel(channel))
svg.tablevalues(`tableValues`, tv)
}
// FeGaussianBlur specifies a Gaussian Blur filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feGaussianBlurElement
func (svg *SVG) FeGaussianBlur(fs Filterspec, stdx, stdy float64, s ...string) {
if stdx < 0 {
stdx = 0
}
if stdy < 0 {
stdy = 0
}
svg.printf(`<feGaussianBlur %s stdDeviation="%g %g" %s`,
fsattr(fs), stdx, stdy, endstyle(s, emptyclose))
}
// FeImage specifies a feImage filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feImageElement
func (svg *SVG) FeImage(href string, result string, s ...string) {
svg.printf(`<feImage xlink:href="%s" result="%s" %s`,
href, result, endstyle(s, emptyclose))
}
// FeMerge specifies a feMerge filter primitive, containing feMerge elements
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feMergeElement
func (svg *SVG) FeMerge(nodes []string, s ...string) {
svg.println(`<feMerge>`)
for _, n := range nodes {
svg.printf("<feMergeNode in=\"%s\"/>\n", n)
}
svg.println(`</feMerge>`)
}
// FeMorphology specifies a feMorphologyLight filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feMorphologyElement
func (svg *SVG) FeMorphology(fs Filterspec, operator string, xradius, yradius float64, s ...string) {
switch operator {
case "erode", "dilate":
break
default:
operator = "erode"
}
svg.printf(`<feMorphology %s operator="%s" radius="%g %g" %s`,
fsattr(fs), operator, xradius, yradius, endstyle(s, emptyclose))
}
// FeOffset specifies the feOffset filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feOffsetElement
func (svg *SVG) FeOffset(fs Filterspec, dx, dy int, s ...string) {
svg.printf(`<feOffset %s dx="%d" dy="%d" %s`,
fsattr(fs), dx, dy, endstyle(s, emptyclose))
}
// FePointLight specifies a fePpointLight filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#fePointLightElement
func (svg *SVG) FePointLight(x, y, z float64, s ...string) {
svg.printf(`<fePointLight x="%g" y="%g" z="%g" %s`,
x, y, z, endstyle(s, emptyclose))
}
// FeSpecularLighting specifies a specular lighting filter primitive,
// a container for light source elements, end with SpecularEnd()
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feSpecularLightingElement
func (svg *SVG) FeSpecularLighting(fs Filterspec, scale, constant float64, exponent int, color string, s ...string) {
svg.printf(`<feSpecularLighting %s surfaceScale="%g" specularConstant="%g" specularExponent="%d" lighting-color="%s" %s`,
fsattr(fs), scale, constant, exponent, color, endstyle(s, ">\n"))
}
// FeSpecEnd ends a specular lighting filter primitive container
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feSpecularLightingElement
func (svg *SVG) FeSpecEnd() {
svg.println(`</feSpecularLighting>`)
}
// FeSpotLight specifies a feSpotLight filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feSpotLightElement
func (svg *SVG) FeSpotLight(fs Filterspec, x, y, z, px, py, pz float64, s ...string) {
svg.printf(`<feSpotLight %s x="%g" y="%g" z="%g" pointsAtX="%g" pointsAtY="%g" pointsAtZ="%g" %s`,
fsattr(fs), x, y, z, px, py, pz, endstyle(s, emptyclose))
}
// FeTile specifies the tile utility filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feTileElement
func (svg *SVG) FeTile(fs Filterspec, in string, s ...string) {
svg.printf(`<feTile %s %s`, fsattr(fs), endstyle(s, emptyclose))
}
// FeTurbulence specifies a turbulence filter primitive
// Standard reference: http://www.w3.org/TR/SVG11/filters.html#feTurbulenceElement
func (svg *SVG) FeTurbulence(fs Filterspec, ftype string, bfx, bfy float64, octaves int, seed int64, stitch bool, s ...string) {
if bfx < 0 || bfx > 1 {
bfx = 0
}
if bfy < 0 || bfy > 1 {
bfy = 0
}
switch ftype[0:1] {
case "f", "F":
ftype = "fractalNoise"
case "t", "T":
ftype = "turbulence"
default:
ftype = "turbulence"
}
var ss string
if stitch {
ss = "stitch"
} else {
ss = "noStitch"
}
svg.printf(`<feTurbulence %s type="%s" baseFrequency="%.2f %.2f" numOctaves="%d" seed="%d" stitchTiles="%s" %s`,
fsattr(fs), ftype, bfx, bfy, octaves, seed, ss, endstyle(s, emptyclose))
}
// Filter Effects convenience functions, modeled after CSS versions
// Blur emulates the CSS blur filter
func (svg *SVG) Blur(p float64) {
svg.FeGaussianBlur(Filterspec{}, p, p)
}
// Brightness emulates the CSS brightness filter
func (svg *SVG) Brightness(p float64) {
svg.FeComponentTransfer()
svg.FeFuncLinear("R", p, 0)
svg.FeFuncLinear("G", p, 0)
svg.FeFuncLinear("B", p, 0)
svg.FeCompEnd()
}
// Contrast emulates the CSS contrast filter
//func (svg *SVG) Contrast(p float64) {
//}
// Dropshadow emulates the CSS dropshadow filter
//func (svg *SVG) Dropshadow(p float64) {
//}
// Grayscale eumulates the CSS grayscale filter
func (svg *SVG) Grayscale() {
svg.FeColorMatrixSaturate(Filterspec{}, 0)
}
// HueRotate eumulates the CSS huerotate filter
func (svg *SVG) HueRotate(a float64) {
svg.FeColorMatrixHue(Filterspec{}, a)
}
// Invert eumulates the CSS invert filter
func (svg *SVG) Invert() {
svg.FeComponentTransfer()
svg.FeFuncTable("R", []float64{1, 0})
svg.FeFuncTable("G", []float64{1, 0})
svg.FeFuncTable("B", []float64{1, 0})
svg.FeCompEnd()
}
// Saturate eumulates the CSS saturate filter
func (svg *SVG) Saturate(p float64) {
svg.FeColorMatrixSaturate(Filterspec{}, p)
}
// Sepia applies a sepia tone, emulating the CSS sepia filter
func (svg *SVG) Sepia() {
var sepiamatrix = [20]float64{
0.280, 0.450, 0.05, 0, 0,
0.140, 0.390, 0.04, 0, 0,
0.080, 0.280, 0.03, 0, 0,
0, 0, 0, 1, 0,
}
svg.FeColorMatrix(Filterspec{}, sepiamatrix)
}
// Utility
// Grid draws a grid at the specified coordinate, dimensions, and spacing, with optional style.
func (svg *SVG) Grid(x int, y int, w int, h int, n int, s ...string) {
if len(s) > 0 {
svg.Gstyle(s[0])
}
for ix := x; ix <= x+w; ix += n {
svg.Line(ix, y, ix, y+h)
}
for iy := y; iy <= y+h; iy += n {
svg.Line(x, iy, x+w, iy)
}
if len(s) > 0 {
svg.Gend()
}
}
// Support functions
// style returns a style name,attribute string
func style(s string) string {
if len(s) > 0 {
return fmt.Sprintf(`style="%s"`, s)
}
return s
}
// pp returns a series of polygon points
func (svg *SVG) pp(x []int, y []int, tag string) {
svg.print(tag)
if len(x) != len(y) {
svg.print(" ")
return
}
lx := len(x) - 1
for i := 0; i < lx; i++ {
svg.print(coord(x[i], y[i]) + " ")
}
svg.print(coord(x[lx], y[lx]))
}
// endstyle modifies an SVG object, with either a series of name="value" pairs,
// or a single string containing a style
func endstyle(s []string, endtag string) string {
if len(s) > 0 {
nv := ""
for i := 0; i < len(s); i++ {
if strings.Index(s[i], "=") > 0 {
nv += (s[i]) + " "
} else {
nv += style(s[i]) + " "
}
}
return nv + endtag
}
return endtag
}
// tt creates a xml element, tag containing s
func (svg *SVG) tt(tag string, s string) {
svg.print("<" + tag + ">")
xml.Escape(svg.Writer, []byte(s))
svg.println("</" + tag + ">")
}
// poly compiles the polygon element
func (svg *SVG) poly(x []int, y []int, tag string, s ...string) {
svg.pp(x, y, "<"+tag+" points=\"")
svg.print(`" ` + endstyle(s, "/>\n"))
}
// onezero returns "0" or "1"
func onezero(flag bool) string {
if flag {
return "1"
}
return "0"
}
// pct returns a percetage, capped at 100
func pct(n uint8) uint8 {
if n > 100 {
return 100
}
return n
}
// islink determines if a string is a script reference
func islink(link string) bool {
return strings.HasPrefix(link, "http://") || strings.HasPrefix(link, "#") ||
strings.HasPrefix(link, "../") || strings.HasPrefix(link, "./")
}
// group returns a group element
func group(tag string, value string) string { return fmt.Sprintf(`<g %s="%s">`, tag, value) }
// scale return the scale string for the transform
func scale(n float64) string { return fmt.Sprintf(`scale(%g)`, n) }
// scaleXY return the scale string for the transform
func scaleXY(dx, dy float64) string { return fmt.Sprintf(`scale(%g,%g)`, dx, dy) }
// skewx returns the skewX string for the transform
func skewX(angle float64) string { return fmt.Sprintf(`skewX(%g)`, angle) }
// skewx returns the skewX string for the transform
func skewY(angle float64) string { return fmt.Sprintf(`skewY(%g)`, angle) }
// rotate returns the rotate string for the transform
func rotate(r float64) string { return fmt.Sprintf(`rotate(%g)`, r) }
// translate returns the translate string for the transform
func translate(x, y int) string { return fmt.Sprintf(`translate(%d,%d)`, x, y) }
// coord returns a coordinate string
func coord(x int, y int) string { return fmt.Sprintf(`%d,%d`, x, y) }
// ptag returns the beginning of the path element
func ptag(x int, y int) string { return fmt.Sprintf(`<path d="M%s`, coord(x, y)) }
// loc returns the x and y coordinate attributes
func loc(x int, y int) string { return fmt.Sprintf(`x="%d" y="%d"`, x, y) }
// href returns the href name and attribute
func href(s string) string { return fmt.Sprintf(`xlink:href="%s"`, s) }
// dim returns the dimension string (x, y coordinates and width, height)
func dim(x int, y int, w int, h int) string {
return fmt.Sprintf(`x="%d" y="%d" width="%d" height="%d"`, x, y, w, h)
}
// fsattr returns the XML attribute representation of a filterspec, ignoring empty attributes
func fsattr(s Filterspec) string {
attrs := ""
if len(s.In) > 0 {
attrs += fmt.Sprintf(`in="%s" `, s.In)
}
if len(s.In2) > 0 {
attrs += fmt.Sprintf(`in2="%s" `, s.In2)
}
if len(s.Result) > 0 {
attrs += fmt.Sprintf(`result="%s" `, s.Result)
}
return attrs
}
// tablevalues outputs a series of values as a XML attribute
func (svg *SVG) tablevalues(s string, t []float64) {
svg.printf(` %s="`, s)
for i := 0; i < len(t)-1; i++ {
svg.printf("%g ", t[i])
}
svg.printf(`%g"%s`, t[len(t)-1], emptyclose)
}
// imgchannel validates the image channel indicator
func imgchannel(c string) string {
switch c {
case "R", "G", "B", "A":
return c
case "r", "g", "b", "a":
return strings.ToUpper(c)
case "red", "green", "blue", "alpha":
return strings.ToUpper(c[0:1])
case "Red", "Green", "Blue", "Alpha":
return c[0:1]
}
return "R"
}

BIN
vendor/github.com/ajstarks/svgo/svgdef.pdf generated vendored Normal file
View File

Binary file not shown.

BIN
vendor/github.com/ajstarks/svgo/svgdef.png generated vendored Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 412 KiB

395
vendor/github.com/ajstarks/svgo/svgdef.svg generated vendored Normal file
View File

@@ -0,0 +1,395 @@
<?xml version="1.0"?>
<!-- Generated by SVGo -->
<svg width="4500" height="3375"
xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink">
<desc>Object Definitions</desc>
<defs>
<linearGradient id="linear" x1="0%" y1="0%" x2="100%" y2="0%">
<stop offset="0%" stop-color="white" stop-opacity="1.00"/>
<stop offset="25%" stop-color="lightblue" stop-opacity="1.00"/>
<stop offset="75%" stop-color="blue" stop-opacity="1.00"/>
<stop offset="100%" stop-color="rgb(0,0,127)" stop-opacity="1.00"/>
</linearGradient>
<radialGradient id="radial" cx="0%" cy="0%" r="100%" fx="50%" fy="50%">
<stop offset="0%" stop-color="white" stop-opacity="1.00"/>
<stop offset="25%" stop-color="lightblue" stop-opacity="1.00"/>
<stop offset="75%" stop-color="blue" stop-opacity="1.00"/>
<stop offset="100%" stop-color="rgb(0,0,127)" stop-opacity="1.00"/>
</radialGradient>
<path d="M 0,0 A62,62 0 0 1 250,0" id="tpath" />
<g id="square">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<rect x="0" y="0" width="125" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="62" y="-24" style="fill:gray; text-anchor:middle">w</text>
<text x="62" y="149" style="fill:black; text-anchor:middle;font-size:24px">Square(x, y, w int, style ...string)</text>
</g>
<g id="rect">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<rect x="0" y="0" width="250" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="-24" y="62" style="fill:gray; text-anchor:middle">h</text>
<text x="125" y="-24" style="fill:gray; text-anchor:middle">w</text>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Rect(x, y, w, h int, style ...string)</text>
</g>
<g id="crect">
<circle cx="125" cy="62" r="4" style="fill:rgb(220,220,220)"/>
<text x="125" y="38" style="fill:gray; text-anchor:middle">x, y</text>
<rect x="0" y="0" width="250" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="-24" y="62" style="fill:gray; text-anchor:middle">h</text>
<text x="125" y="-24" style="fill:gray; text-anchor:middle">w</text>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">CenterRect(x, y, w, h int, style ...string)</text>
</g>
<g id="roundrect">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<rect x="0" y="0" width="250" height="125" rx="25" ry="25" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="-24" y="62" style="fill:gray; text-anchor:middle">h</text>
<text x="125" y="-24" style="fill:gray; text-anchor:middle">w</text>
<line x1="25" y1="0" x2="25" y2="25" style="stroke:black; stroke-width:1"/>
<line x1="0" y1="25" x2="25" y2="25" style="stroke:black; stroke-width:1"/>
<text x="49" y="13" style="fill:gray; text-anchor:middle">ry</text>
<text x="12" y="49" style="fill:gray; text-anchor:middle">rx</text>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Roundrect(x, y, w, h, rx, ry int, style ...string)</text>
</g>
<g id="polygon">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<circle cx="125" cy="-31" r="4" style="fill:rgb(220,220,220)"/>
<text x="125" y="-55" style="fill:gray; text-anchor:middle">x, y</text>
<circle cx="250" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="250" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<circle cx="250" cy="93" r="4" style="fill:rgb(220,220,220)"/>
<text x="250" y="69" style="fill:gray; text-anchor:middle">x, y</text>
<circle cx="125" cy="62" r="4" style="fill:rgb(220,220,220)"/>
<text x="125" y="38" style="fill:gray; text-anchor:middle">x, y</text>
<circle cx="0" cy="93" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="69" style="fill:gray; text-anchor:middle">x, y</text>
<polygon points="0,0 125,-31 250,0 250,93 125,62 0,93" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Polygon(x, y []int, style ...string)</text>
</g>
<g id="circle">
<g transform="translate(125,62)">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<circle cx="0" cy="0" r="62" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<line x1="0" y1="0" x2="62" y2="0" style="stroke:black; stroke-width:1"/>
<text x="31" y="24" style="fill:gray; text-anchor:middle">r</text>
<text x="0" y="86" style="fill:black; text-anchor:middle;font-size:24px">Circle(x, y, r int, style ...string)</text>
</g>
</g>
<g id="ellipse">
<g transform="translate(125,62)">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<ellipse cx="0" cy="0" rx="125" ry="62" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<line x1="0" y1="0" x2="125" y2="0" style="stroke:black; stroke-width:1"/>
<line x1="0" y1="0" x2="0" y2="62" style="stroke:black; stroke-width:1"/>
<text x="62" y="24" style="fill:gray; text-anchor:middle">rx</text>
<text x="-24" y="31" style="fill:gray; text-anchor:middle">ry</text>
<text x="0" y="86" style="fill:black; text-anchor:middle;font-size:24px">Ellipse(x, y, rx, ry int, style ...string)</text>
</g>
</g>
<g id="line">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x1, y1</text>
<circle cx="250" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="250" y="-24" style="fill:gray; text-anchor:middle">x2, y2</text>
<line x1="0" y1="0" x2="250" y2="0" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Line(x1, y1, x2, y2 int, style ...string)</text>
</g>
<g id="polyline">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<circle cx="83" cy="-62" r="4" style="fill:rgb(220,220,220)"/>
<text x="83" y="-86" style="fill:gray; text-anchor:middle">x, y</text>
<circle cx="187" cy="-41" r="4" style="fill:rgb(220,220,220)"/>
<text x="187" y="-65" style="fill:gray; text-anchor:middle">x, y</text>
<circle cx="250" cy="-125" r="4" style="fill:rgb(220,220,220)"/>
<text x="250" y="-149" style="fill:gray; text-anchor:middle">x, y</text>
<polyline points="0,0 83,-62 187,-41 250,-125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Polyline(x, y []int, style ...string)</text>
</g>
<g id="arc">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">sx, sy</text>
<circle cx="250" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="250" y="-24" style="fill:gray; text-anchor:middle">ex, ey</text>
<path d="M0,0 A62,62 0 0 1 250,0" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="125" y="148" style="fill:black; text-anchor:middle;font-size:24px">Arc(sx, sy, ax, ay, r int, lflag, sflag bool, ex, ey int, style ...string)</text>
</g>
<g id="path">
<path d="M36,5l12,41l12-41h33v4l-13,21c30,10,2,69-21,28l7-2c15,27,33,-22,3,-19v-4l12-20h-15l-17,59h-1l-13-42l-12,42h-1l-20-67h9l12,41l8-28l-4-13h9" fill="rgb(0,0,127)" />
<path d="M94,53c15,32,30,14,35,7l-1-7c-16,26-32,3-34,0M122,16c-10-21-34,0-21,30c-5-30 16,-38 23,-21l5-10l-2-9" style="fill-opacity:0.50; fill:rgb(0,0,0)"/>
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<text x="62" y="160" style="fill:black; text-anchor:middle;font-size:24px">Path(s string, style ...string)</text>
</g>
<g id="qbez">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">sx, sy</text>
<circle cx="41" cy="-93" r="4" style="fill:rgb(220,220,220)"/>
<text x="41" y="-117" style="fill:gray; text-anchor:middle">cx, cy</text>
<circle cx="250" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="250" y="-24" style="fill:gray; text-anchor:middle">ex, ey</text>
<path d="M0,0 Q41,-93 250,0" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Qbez(sx, sy, cx, cy, ex, ey int, style ...string)</text>
</g>
<g id="bezier">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">sx, sy</text>
<circle cx="125" cy="-62" r="4" style="fill:rgb(220,220,220)"/>
<text x="125" y="-86" style="fill:gray; text-anchor:middle">cx, cy</text>
<circle cx="125" cy="62" r="4" style="fill:rgb(220,220,220)"/>
<text x="125" y="38" style="fill:gray; text-anchor:middle">px, py</text>
<circle cx="250" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="250" y="-24" style="fill:gray; text-anchor:middle">ex, ey</text>
<path d="M0,0 C125,-62 125,62 250,0" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Bezier(sx, sy, cx, cy, px, py, ex, ey int, style ...string)</text>
</g>
<g id="image">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<rect x="0" y="0" width="128" height="128" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<text x="-24" y="64" style="fill:gray; text-anchor:middle">h</text>
<text x="64" y="-24" style="fill:gray; text-anchor:middle">w</text>
<image x="0" y="0" width="128" height="128" xlink:href="gophercolor128x128.png" />
<text x="64" y="152" style="fill:black; text-anchor:middle;font-size:24px">Image(x, y, w, h, int path string, style ...string)</text>
</g>
<g id="lgrad">
<rect x="0" y="0" width="250" height="125" style="fill:url(#linear)"/>
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x1%, y1%</text>
<circle cx="250" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="250" y="-24" style="fill:gray; text-anchor:middle">x2%, y2%</text>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">LinearGradient(s string, x1, y1, x2, y2 uint8, oc []Offcolor)</text>
</g>
<g id="rgrad">
<rect x="0" y="0" width="250" height="125" style="fill:url(#radial)"/>
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">cx%, cy%</text>
<circle cx="125" cy="62" r="4" style="fill:rgb(220,220,220)"/>
<text x="125" y="38" style="fill:gray; text-anchor:middle">fx%, fy%</text>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">RadialGradient(s string, cx, cy, r, fx, fy uint8, oc []Offcolor)</text>
</g>
<g id="trans">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">0, 0</text>
<circle cx="167" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="167" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Translate(x, y int)</text>
<rect x="0" y="0" width="83" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<g transform="translate(167,0)">
<rect x="0" y="0" width="83" height="125" style="fill-opacity:0.25;fill:rgb(0,0,127)"/>
</g>
</g>
<g id="grid">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">x, y</text>
<text x="-24" y="62" style="fill:gray; text-anchor:middle">h</text>
<text x="125" y="-24" style="fill:gray; text-anchor:middle">w</text>
<text x="55" y="15" style="fill:gray; text-anchor:middle">n</text>
<g style="stroke:rgb(0,0,127)">
<line x1="0" y1="0" x2="0" y2="125" />
<line x1="31" y1="0" x2="31" y2="125" />
<line x1="62" y1="0" x2="62" y2="125" />
<line x1="93" y1="0" x2="93" y2="125" />
<line x1="124" y1="0" x2="124" y2="125" />
<line x1="155" y1="0" x2="155" y2="125" />
<line x1="186" y1="0" x2="186" y2="125" />
<line x1="217" y1="0" x2="217" y2="125" />
<line x1="248" y1="0" x2="248" y2="125" />
<line x1="0" y1="0" x2="250" y2="0" />
<line x1="0" y1="31" x2="250" y2="31" />
<line x1="0" y1="62" x2="250" y2="62" />
<line x1="0" y1="93" x2="250" y2="93" />
<line x1="0" y1="124" x2="250" y2="124" />
</g>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Grid(x, y, w, h, n int, style ...string)</text>
</g>
<g id="text">
<circle cx="0" cy="62" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="86" style="fill:gray; text-anchor:middle">x, y</text>
<text x="0" y="62" style="text-anchor:start;font-size:32pt">hello, this is SVG</text>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Text(x, y int, s string, style ...string)</text>
</g>
<g id="scale">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">0, 0</text>
<rect x="0" y="0" width="250" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<g transform="scale(0.5)">
<rect x="0" y="0" width="250" height="125" style="fill-opacity:0.25;fill:rgb(0,0,127)"/>
</g>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Scale(n float64)</text>
</g>
<g id="scalexy">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">0, 0</text>
<rect x="0" y="0" width="250" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<g transform="scale(0.5,0.75)">
<rect x="0" y="0" width="250" height="125" style="fill-opacity:0.25;fill:rgb(0,0,127)"/>
</g>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">ScaleXY(x, y float64)</text>
</g>
<g id="skewx">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">0, 0</text>
<rect x="0" y="0" width="250" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<g transform="skewX(30)">
<rect x="0" y="0" width="250" height="125" style="fill-opacity:0.25;fill:rgb(0,0,127)"/>
</g>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">SkewX(a float64)</text>
</g>
<g id="skewy">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">0, 0</text>
<rect x="0" y="0" width="250" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<g transform="skewY(10)">
<rect x="0" y="0" width="250" height="125" style="fill-opacity:0.25;fill:rgb(0,0,127)"/>
</g>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">SkewY(a float64)</text>
</g>
<g id="skewxy">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">0, 0</text>
<rect x="0" y="0" width="250" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<g transform="skewX(10) skewY(10)">
<rect x="0" y="0" width="250" height="125" style="fill-opacity:0.25;fill:rgb(0,0,127)"/>
</g>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">SkewXY(x, y float64)</text>
</g>
<g id="rotate">
<circle cx="0" cy="0" r="4" style="fill:rgb(220,220,220)"/>
<text x="0" y="-24" style="fill:gray; text-anchor:middle">0, 0</text>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Rotate(r float64)</text>
<rect x="0" y="0" width="250" height="125" style="fill:none; stroke-width:2;stroke:rgb(0,0,127)"/>
<path d="M125,0 Q135,31 108,62" style="fill:none;stroke:gray"/>
<text x="62" y="24" style="fill:gray; text-anchor:middle">r</text>
<g transform="rotate(30)">
<rect x="0" y="0" width="250" height="125" style="fill-opacity:0.25;fill:rgb(0,0,127)"/>
</g>
</g>
<g id="textpath">
<text fill="rgb(0,0,127)" text-anchor="start" font-size="16pt" ><textPath xlink:href="#tpath">It&#39;s &#34;fine&#34; &amp; &#34;dandy&#34; to draw text along a path</textPath></text>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">Textpath(s, pathid string, style ...string)</text>
</g>
<g id="meta">
<g style="font-size:24px;fill:black;text-anchor:start">
<text x="0" y="24" >New(w io Writer)</text>
<text x="0" y="52" >Start(w, h int, options ...string)/End()</text>
<text x="0" y="80" >Startview(w, h, minx, miny, vw, vh int)</text>
<text x="0" y="108" >Group(s ...string)/Gend()</text>
<text x="0" y="136" >Gstyle(s string)/Gend()</text>
<text x="0" y="164" >Gtransform(s string)/Gend()</text>
<text x="0" y="192" >Gid(id string)/Gend()</text>
<text x="0" y="220" >ClipPath(s ...string)/ClipEnd()</text>
<text x="0" y="248" >Def()/DefEnd()</text>
<text x="0" y="276" >Marker()/MarkerEnd()</text>
<text x="0" y="304" >Pattern()/PatternEnd()</text>
<text x="0" y="332" >Desc(s string)</text>
<text x="0" y="360" >Title(s string)</text>
<text x="0" y="388" >Script(type, data ...string)</text>
<text x="0" y="416" >Mask(id string, x,y,w,h int, style ...string)/MaskEnd()</text>
<text x="0" y="444" >Link(href string, title string)/LinkEnd()</text>
<text x="0" y="472" >Use(x int, y int, link string, style ...string)</text>
</g>
<g style="font-size:24px;fill:rgb(127,127,127);text-anchor:start">
<text x="650" y="24" >specify destination</text>
<text x="650" y="52" >begin/end the document</text>
<text x="650" y="80" >begin/end the document with viewport</text>
<text x="650" y="108" >begin/end group with attributes</text>
<text x="650" y="136" >begin/end group style</text>
<text x="650" y="164" >begin/end group transform</text>
<text x="650" y="192" >begin/end group id</text>
<text x="650" y="220" >begin/end clip path</text>
<text x="650" y="248" >begin/end a defintion block</text>
<text x="650" y="276" >begin/end markers</text>
<text x="650" y="304" >begin/end pattern</text>
<text x="650" y="332" >set the description element</text>
<text x="650" y="360" >set the title element</text>
<text x="650" y="388" >define a script</text>
<text x="650" y="416" >begin/end mask element</text>
<text x="650" y="444" >begin/end link to href, with a title</text>
<text x="650" y="472" >use defined objects</text>
</g>
<text x="500" y="534" style="fill:black; text-anchor:middle;font-size:24px">Textlines(x, y int, s []string, size, spacing int, fill, align string)</text>
</g>
<g id="rgb">
<g style="fill:gray; text-anchor:middle">
<circle cx="62" cy="0" r="15" style="fill:rgb(44,0,0)"/>
<circle cx="125" cy="0" r="15" style="fill:rgb(0,77,0)"/>
<circle cx="187" cy="0" r="15" style="fill:rgb(0,0,232)"/>
<circle cx="250" cy="0" r="15" style="fill:rgb(44,77,232)"/>
<text x="62" y="62" >r</text>
<text x="125" y="62" >g</text>
<text x="187" y="62" >b</text>
<text x="219" y="8" >-&gt;</text>
</g>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">RGB(r, g, b int)</text>
</g>
<g id="rgba">
<g style="fill:gray; text-anchor:middle">
<circle cx="62" cy="0" r="15" style="fill:rgb(44,0,0)"/>
<circle cx="125" cy="0" r="15" style="fill:rgb(0,77,0)"/>
<circle cx="187" cy="0" r="15" style="fill:rgb(0,0,232)"/>
<circle cx="250" cy="0" r="15" style="fill-opacity:0.33; fill:rgb(44,77,232)"/>
<circle cx="260" cy="0" r="15" style="fill-opacity:0.33; fill:rgb(44,77,232)"/>
<text x="250" y="62" >alpha</text>
<text x="62" y="62" >r</text>
<text x="125" y="62" >g</text>
<text x="187" y="62" >b</text>
<text x="219" y="8" >-&gt;</text>
</g>
<text x="125" y="149" style="fill:black; text-anchor:middle;font-size:24px">RGBA(r, g, b int, opacity float64)</text>
</g>
</defs>
<title>SVG Go Library Description</title>
<rect x="0" y="0" width="4500" height="3375" style="fill:white;stroke:black;stroke-width:2"/>
<g style="font-family:Calibri,sans; text-anchor:middle; font-size:24px">
<a xlink:href="http://github.com/ajstarks/svgo" xlink:title="SVGo Library">
<text x="2250" y="150" style="font-size:125px">SVG Go Library</text>
<text x="2250" y="200" style="font-size:50px;fill:gray">github.com/ajstarks/svgo</text>
</a>
<desc>Object Usage</desc>
<g transform="translate(400,400)">
<use x="0" y="0" xlink:href="#rect" />
<use x="700" y="0" xlink:href="#crect" />
<use x="1400" y="0" xlink:href="#roundrect" />
<use x="2100" y="0" xlink:href="#square" />
<use x="2800" y="0" xlink:href="#line" />
<use x="3500" y="0" xlink:href="#polyline" />
</g>
<g transform="translate(400,1000)">
<use x="0" y="0" xlink:href="#polygon" />
<use x="700" y="0" xlink:href="#circle" />
<use x="1400" y="0" xlink:href="#ellipse" />
<use x="2100" y="0" xlink:href="#arc" />
<use x="2800" y="0" xlink:href="#qbez" />
<use x="3500" y="0" xlink:href="#bezier" />
</g>
<g transform="translate(400,1600)">
<use x="0" y="0" xlink:href="#trans" />
<use x="700" y="0" xlink:href="#scale" />
<use x="1400" y="0" xlink:href="#scalexy" />
<use x="2100" y="0" xlink:href="#skewx" />
<use x="2800" y="0" xlink:href="#skewy" />
<use x="3500" y="0" xlink:href="#skewxy" />
</g>
<g transform="translate(400,2200)">
<use x="0" y="0" xlink:href="#rotate" />
<use x="700" y="0" xlink:href="#text" />
<use x="1400" y="0" xlink:href="#textpath" />
<use x="2100" y="0" xlink:href="#path" />
<use x="2800" y="0" xlink:href="#image" />
<use x="3500" y="0" xlink:href="#grid" />
</g>
<g transform="translate(400,2800)">
<use x="0" y="0" xlink:href="#lgrad" />
<use x="700" y="0" xlink:href="#rgrad" />
<use x="1400" y="0" xlink:href="#rgb" />
<use x="2100" y="0" xlink:href="#rgba" />
<use x="2800" y="0" xlink:href="#meta" />
</g>
</g>
</svg>
Side by Side

After

Width:  |  Height:  |  Size: 21 KiB