GOPROXY means we can avoid vendoring

18 files changed, 0 insertions, 1739 deletions

diff --git a/vendor/github.com/fogleman/primitive/LICENSE.md b/vendor/github.com/fogleman/primitive/LICENSE.md
deleted file mode 100644
index d7b4099..0000000
--- a/vendor/github.com/fogleman/primitive/LICENSE.md
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (C) 2016 Michael Fogleman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/vendor/github.com/fogleman/primitive/primitive/color.go b/vendor/github.com/fogleman/primitive/primitive/color.go
deleted file mode 100644
index 2828957..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/color.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package primitive
-
-import (
-	"fmt"
-	"image/color"
-	"strings"
-)
-
-type Color struct {
-	R, G, B, A int
-}
-
-func MakeColor(c color.Color) Color {
-	r, g, b, a := c.RGBA()
-	return Color{int(r / 257), int(g / 257), int(b / 257), int(a / 257)}
-}
-
-func MakeHexColor(x string) Color {
-	x = strings.Trim(x, "#")
-	var r, g, b, a int
-	a = 255
-	switch len(x) {
-	case 3:
-		fmt.Sscanf(x, "%1x%1x%1x", &r, &g, &b)
-		r = (r << 4) | r
-		g = (g << 4) | g
-		b = (b << 4) | b
-	case 4:
-		fmt.Sscanf(x, "%1x%1x%1x%1x", &r, &g, &b, &a)
-		r = (r << 4) | r
-		g = (g << 4) | g
-		b = (b << 4) | b
-		a = (a << 4) | a
-	case 6:
-		fmt.Sscanf(x, "%02x%02x%02x", &r, &g, &b)
-	case 8:
-		fmt.Sscanf(x, "%02x%02x%02x%02x", &r, &g, &b, &a)
-	}
-	return Color{r, g, b, a}
-}
-
-func (c *Color) NRGBA() color.NRGBA {
-	return color.NRGBA{uint8(c.R), uint8(c.G), uint8(c.B), uint8(c.A)}
-}
diff --git a/vendor/github.com/fogleman/primitive/primitive/core.go b/vendor/github.com/fogleman/primitive/primitive/core.go
deleted file mode 100644
index 5a0c0aa..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/core.go
+++ /dev/null
@@ -1,124 +0,0 @@
-package primitive
-
-import (
-	"image"
-	"math"
-)
-
-func computeColor(target, current *image.RGBA, lines []Scanline, alpha int) Color {
-	var rsum, gsum, bsum, count int64
-	a := 0x101 * 255 / alpha
-	for _, line := range lines {
-		i := target.PixOffset(line.X1, line.Y)
-		for x := line.X1; x <= line.X2; x++ {
-			tr := int(target.Pix[i])
-			tg := int(target.Pix[i+1])
-			tb := int(target.Pix[i+2])
-			cr := int(current.Pix[i])
-			cg := int(current.Pix[i+1])
-			cb := int(current.Pix[i+2])
-			i += 4
-			rsum += int64((tr-cr)*a + cr*0x101)
-			gsum += int64((tg-cg)*a + cg*0x101)
-			bsum += int64((tb-cb)*a + cb*0x101)
-			count++
-		}
-	}
-	if count == 0 {
-		return Color{}
-	}
-	r := clampInt(int(rsum/count)>>8, 0, 255)
-	g := clampInt(int(gsum/count)>>8, 0, 255)
-	b := clampInt(int(bsum/count)>>8, 0, 255)
-	return Color{r, g, b, alpha}
-}
-
-func copyLines(dst, src *image.RGBA, lines []Scanline) {
-	for _, line := range lines {
-		a := dst.PixOffset(line.X1, line.Y)
-		b := a + (line.X2-line.X1+1)*4
-		copy(dst.Pix[a:b], src.Pix[a:b])
-	}
-}
-
-func drawLines(im *image.RGBA, c Color, lines []Scanline) {
-	const m = 0xffff
-	sr, sg, sb, sa := c.NRGBA().RGBA()
-	for _, line := range lines {
-		ma := line.Alpha
-		a := (m - sa*ma/m) * 0x101
-		i := im.PixOffset(line.X1, line.Y)
-		for x := line.X1; x <= line.X2; x++ {
-			dr := uint32(im.Pix[i+0])
-			dg := uint32(im.Pix[i+1])
-			db := uint32(im.Pix[i+2])
-			da := uint32(im.Pix[i+3])
-			im.Pix[i+0] = uint8((dr*a + sr*ma) / m >> 8)
-			im.Pix[i+1] = uint8((dg*a + sg*ma) / m >> 8)
-			im.Pix[i+2] = uint8((db*a + sb*ma) / m >> 8)
-			im.Pix[i+3] = uint8((da*a + sa*ma) / m >> 8)
-			i += 4
-		}
-	}
-}
-
-func differenceFull(a, b *image.RGBA) float64 {
-	size := a.Bounds().Size()
-	w, h := size.X, size.Y
-	var total uint64
-	for y := 0; y < h; y++ {
-		i := a.PixOffset(0, y)
-		for x := 0; x < w; x++ {
-			ar := int(a.Pix[i])
-			ag := int(a.Pix[i+1])
-			ab := int(a.Pix[i+2])
-			aa := int(a.Pix[i+3])
-			br := int(b.Pix[i])
-			bg := int(b.Pix[i+1])
-			bb := int(b.Pix[i+2])
-			ba := int(b.Pix[i+3])
-			i += 4
-			dr := ar - br
-			dg := ag - bg
-			db := ab - bb
-			da := aa - ba
-			total += uint64(dr*dr + dg*dg + db*db + da*da)
-		}
-	}
-	return math.Sqrt(float64(total)/float64(w*h*4)) / 255
-}
-
-func differencePartial(target, before, after *image.RGBA, score float64, lines []Scanline) float64 {
-	size := target.Bounds().Size()
-	w, h := size.X, size.Y
-	total := uint64(math.Pow(score*255, 2) * float64(w*h*4))
-	for _, line := range lines {
-		i := target.PixOffset(line.X1, line.Y)
-		for x := line.X1; x <= line.X2; x++ {
-			tr := int(target.Pix[i])
-			tg := int(target.Pix[i+1])
-			tb := int(target.Pix[i+2])
-			ta := int(target.Pix[i+3])
-			br := int(before.Pix[i])
-			bg := int(before.Pix[i+1])
-			bb := int(before.Pix[i+2])
-			ba := int(before.Pix[i+3])
-			ar := int(after.Pix[i])
-			ag := int(after.Pix[i+1])
-			ab := int(after.Pix[i+2])
-			aa := int(after.Pix[i+3])
-			i += 4
-			dr1 := tr - br
-			dg1 := tg - bg
-			db1 := tb - bb
-			da1 := ta - ba
-			dr2 := tr - ar
-			dg2 := tg - ag
-			db2 := tb - ab
-			da2 := ta - aa
-			total -= uint64(dr1*dr1 + dg1*dg1 + db1*db1 + da1*da1)
-			total += uint64(dr2*dr2 + dg2*dg2 + db2*db2 + da2*da2)
-		}
-	}
-	return math.Sqrt(float64(total)/float64(w*h*4)) / 255
-}
diff --git a/vendor/github.com/fogleman/primitive/primitive/ellipse.go b/vendor/github.com/fogleman/primitive/primitive/ellipse.go
deleted file mode 100644
index 878df40..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/ellipse.go
+++ /dev/null
@@ -1,179 +0,0 @@
-package primitive
-
-import (
-	"fmt"
-	"math"
-
-	"github.com/fogleman/gg"
-	"github.com/golang/freetype/raster"
-)
-
-type Ellipse struct {
-	Worker *Worker
-	X, Y   int
-	Rx, Ry int
-	Circle bool
-}
-
-func NewRandomEllipse(worker *Worker) *Ellipse {
-	rnd := worker.Rnd
-	x := rnd.Intn(worker.W)
-	y := rnd.Intn(worker.H)
-	rx := rnd.Intn(32) + 1
-	ry := rnd.Intn(32) + 1
-	return &Ellipse{worker, x, y, rx, ry, false}
-}
-
-func NewRandomCircle(worker *Worker) *Ellipse {
-	rnd := worker.Rnd
-	x := rnd.Intn(worker.W)
-	y := rnd.Intn(worker.H)
-	r := rnd.Intn(32) + 1
-	return &Ellipse{worker, x, y, r, r, true}
-}
-
-func (c *Ellipse) Draw(dc *gg.Context, scale float64) {
-	dc.DrawEllipse(float64(c.X), float64(c.Y), float64(c.Rx), float64(c.Ry))
-	dc.Fill()
-}
-
-func (c *Ellipse) SVG(attrs string) string {
-	return fmt.Sprintf(
-		"<ellipse %s cx=\"%d\" cy=\"%d\" rx=\"%d\" ry=\"%d\" />",
-		attrs, c.X, c.Y, c.Rx, c.Ry)
-}
-
-func (c *Ellipse) Copy() Shape {
-	a := *c
-	return &a
-}
-
-func (c *Ellipse) Mutate() {
-	w := c.Worker.W
-	h := c.Worker.H
-	rnd := c.Worker.Rnd
-	switch rnd.Intn(3) {
-	case 0:
-		c.X = clampInt(c.X+int(rnd.NormFloat64()*16), 0, w-1)
-		c.Y = clampInt(c.Y+int(rnd.NormFloat64()*16), 0, h-1)
-	case 1:
-		c.Rx = clampInt(c.Rx+int(rnd.NormFloat64()*16), 1, w-1)
-		if c.Circle {
-			c.Ry = c.Rx
-		}
-	case 2:
-		c.Ry = clampInt(c.Ry+int(rnd.NormFloat64()*16), 1, w-1)
-		if c.Circle {
-			c.Rx = c.Ry
-		}
-	}
-}
-
-func (c *Ellipse) Rasterize() []Scanline {
-	w := c.Worker.W
-	h := c.Worker.H
-	lines := c.Worker.Lines[:0]
-	aspect := float64(c.Rx) / float64(c.Ry)
-	for dy := 0; dy < c.Ry; dy++ {
-		y1 := c.Y - dy
-		y2 := c.Y + dy
-		if (y1 < 0 || y1 >= h) && (y2 < 0 || y2 >= h) {
-			continue
-		}
-		s := int(math.Sqrt(float64(c.Ry*c.Ry-dy*dy)) * aspect)
-		x1 := c.X - s
-		x2 := c.X + s
-		if x1 < 0 {
-			x1 = 0
-		}
-		if x2 >= w {
-			x2 = w - 1
-		}
-		if y1 >= 0 && y1 < h {
-			lines = append(lines, Scanline{y1, x1, x2, 0xffff})
-		}
-		if y2 >= 0 && y2 < h && dy > 0 {
-			lines = append(lines, Scanline{y2, x1, x2, 0xffff})
-		}
-	}
-	return lines
-}
-
-type RotatedEllipse struct {
-	Worker *Worker
-	X, Y   float64
-	Rx, Ry float64
-	Angle  float64
-}
-
-func NewRandomRotatedEllipse(worker *Worker) *RotatedEllipse {
-	rnd := worker.Rnd
-	x := rnd.Float64() * float64(worker.W)
-	y := rnd.Float64() * float64(worker.H)
-	rx := rnd.Float64()*32 + 1
-	ry := rnd.Float64()*32 + 1
-	a := rnd.Float64() * 360
-	return &RotatedEllipse{worker, x, y, rx, ry, a}
-}
-
-func (c *RotatedEllipse) Draw(dc *gg.Context, scale float64) {
-	dc.Push()
-	dc.RotateAbout(radians(c.Angle), c.X, c.Y)
-	dc.DrawEllipse(c.X, c.Y, c.Rx, c.Ry)
-	dc.Fill()
-	dc.Pop()
-}
-
-func (c *RotatedEllipse) SVG(attrs string) string {
-	return fmt.Sprintf(
-		"<g transform=\"translate(%f %f) rotate(%f) scale(%f %f)\"><ellipse %s cx=\"0\" cy=\"0\" rx=\"1\" ry=\"1\" /></g>",
-		c.X, c.Y, c.Angle, c.Rx, c.Ry, attrs)
-}
-
-func (c *RotatedEllipse) Copy() Shape {
-	a := *c
-	return &a
-}
-
-func (c *RotatedEllipse) Mutate() {
-	w := c.Worker.W
-	h := c.Worker.H
-	rnd := c.Worker.Rnd
-	switch rnd.Intn(3) {
-	case 0:
-		c.X = clamp(c.X+rnd.NormFloat64()*16, 0, float64(w-1))
-		c.Y = clamp(c.Y+rnd.NormFloat64()*16, 0, float64(h-1))
-	case 1:
-		c.Rx = clamp(c.Rx+rnd.NormFloat64()*16, 1, float64(w-1))
-		c.Ry = clamp(c.Ry+rnd.NormFloat64()*16, 1, float64(w-1))
-	case 2:
-		c.Angle = c.Angle + rnd.NormFloat64()*32
-	}
-}
-
-func (c *RotatedEllipse) Rasterize() []Scanline {
-	var path raster.Path
-	const n = 16
-	for i := 0; i < n; i++ {
-		p1 := float64(i+0) / n
-		p2 := float64(i+1) / n
-		a1 := p1 * 2 * math.Pi
-		a2 := p2 * 2 * math.Pi
-		x0 := c.Rx * math.Cos(a1)
-		y0 := c.Ry * math.Sin(a1)
-		x1 := c.Rx * math.Cos(a1+(a2-a1)/2)
-		y1 := c.Ry * math.Sin(a1+(a2-a1)/2)
-		x2 := c.Rx * math.Cos(a2)
-		y2 := c.Ry * math.Sin(a2)
-		cx := 2*x1 - x0/2 - x2/2
-		cy := 2*y1 - y0/2 - y2/2
-		x0, y0 = rotate(x0, y0, radians(c.Angle))
-		cx, cy = rotate(cx, cy, radians(c.Angle))
-		x2, y2 = rotate(x2, y2, radians(c.Angle))
-		if i == 0 {
-			path.Start(fixp(x0+c.X, y0+c.Y))
-		}
-		path.Add2(fixp(cx+c.X, cy+c.Y), fixp(x2+c.X, y2+c.Y))
-	}
-	return fillPath(c.Worker, path)
-}
diff --git a/vendor/github.com/fogleman/primitive/primitive/heatmap.go b/vendor/github.com/fogleman/primitive/primitive/heatmap.go
deleted file mode 100644
index 7bef5fe..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/heatmap.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package primitive
-
-import (
-	"image"
-	"image/color"
-	"math"
-)
-
-type Heatmap struct {
-	W, H  int
-	Count []uint64
-}
-
-func NewHeatmap(w, h int) *Heatmap {
-	count := make([]uint64, w*h)
-	return &Heatmap{w, h, count}
-}
-
-func (h *Heatmap) Clear() {
-	for i := range h.Count {
-		h.Count[i] = 0
-	}
-}
-
-func (h *Heatmap) Add(lines []Scanline) {
-	for _, line := range lines {
-		i := line.Y*h.W + line.X1
-		for x := line.X1; x <= line.X2; x++ {
-			h.Count[i] += uint64(line.Alpha)
-			i++
-		}
-	}
-}
-
-func (h *Heatmap) AddHeatmap(a *Heatmap) {
-	for i, x := range a.Count {
-		h.Count[i] += x
-	}
-}
-
-func (h *Heatmap) Image(gamma float64) *image.Gray16 {
-	im := image.NewGray16(image.Rect(0, 0, h.W, h.H))
-	var hi uint64
-	for _, h := range h.Count {
-		if h > hi {
-			hi = h
-		}
-	}
-	i := 0
-	for y := 0; y < h.H; y++ {
-		for x := 0; x < h.W; x++ {
-			p := float64(h.Count[i]) / float64(hi)
-			p = math.Pow(p, gamma)
-			im.SetGray16(x, y, color.Gray16{uint16(p * 0xffff)})
-			i++
-		}
-	}
-	return im
-}
diff --git a/vendor/github.com/fogleman/primitive/primitive/log.go b/vendor/github.com/fogleman/primitive/primitive/log.go
deleted file mode 100644
index d162eff..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/log.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package primitive
-
-import "fmt"
-
-var LogLevel int
-
-func Log(level int, format string, a ...interface{}) {
-	if LogLevel >= level {
-		fmt.Printf(format, a...)
-	}
-}
-
-func v(format string, a ...interface{}) {
-	Log(1, format, a...)
-}
-
-func vv(format string, a ...interface{}) {
-	Log(2, "  "+format, a...)
-}
-
-func vvv(format string, a ...interface{}) {
-	Log(3, "    "+format, a...)
-}
diff --git a/vendor/github.com/fogleman/primitive/primitive/model.go b/vendor/github.com/fogleman/primitive/primitive/model.go
deleted file mode 100644
index 80f49ae..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/model.go
+++ /dev/null
@@ -1,174 +0,0 @@
-package primitive
-
-import (
-	"fmt"
-	"image"
-	"strings"
-
-	"github.com/fogleman/gg"
-)
-
-type Model struct {
-	Sw, Sh     int
-	Scale      float64
-	Background Color
-	Target     *image.RGBA
-	Current    *image.RGBA
-	Context    *gg.Context
-	Score      float64
-	Shapes     []Shape
-	Colors     []Color
-	Scores     []float64
-	Workers    []*Worker
-}
-
-func NewModel(target image.Image, background Color, size, numWorkers int) *Model {
-	w := target.Bounds().Size().X
-	h := target.Bounds().Size().Y
-	aspect := float64(w) / float64(h)
-	var sw, sh int
-	var scale float64
-	if aspect >= 1 {
-		sw = size
-		sh = int(float64(size) / aspect)
-		scale = float64(size) / float64(w)
-	} else {
-		sw = int(float64(size) * aspect)
-		sh = size
-		scale = float64(size) / float64(h)
-	}
-
-	model := &Model{}
-	model.Sw = sw
-	model.Sh = sh
-	model.Scale = scale
-	model.Background = background
-	model.Target = imageToRGBA(target)
-	model.Current = uniformRGBA(target.Bounds(), background.NRGBA())
-	model.Score = differenceFull(model.Target, model.Current)
-	model.Context = model.newContext()
-	for i := 0; i < numWorkers; i++ {
-		worker := NewWorker(model.Target)
-		model.Workers = append(model.Workers, worker)
-	}
-	return model
-}
-
-func (model *Model) newContext() *gg.Context {
-	dc := gg.NewContext(model.Sw, model.Sh)
-	dc.Scale(model.Scale, model.Scale)
-	dc.Translate(0.5, 0.5)
-	dc.SetColor(model.Background.NRGBA())
-	dc.Clear()
-	return dc
-}
-
-func (model *Model) Frames(scoreDelta float64) []image.Image {
-	var result []image.Image
-	dc := model.newContext()
-	result = append(result, imageToRGBA(dc.Image()))
-	previous := 10.0
-	for i, shape := range model.Shapes {
-		c := model.Colors[i]
-		dc.SetRGBA255(c.R, c.G, c.B, c.A)
-		shape.Draw(dc, model.Scale)
-		dc.Fill()
-		score := model.Scores[i]
-		delta := previous - score
-		if delta >= scoreDelta {
-			previous = score
-			result = append(result, imageToRGBA(dc.Image()))
-		}
-	}
-	return result
-}
-
-func (model *Model) SVG() string {
-	bg := model.Background
-	var lines []string
-	lines = append(lines, fmt.Sprintf("<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" width=\"%d\" height=\"%d\">", model.Sw, model.Sh))
-	lines = append(lines, fmt.Sprintf("<rect x=\"0\" y=\"0\" width=\"%d\" height=\"%d\" fill=\"#%02x%02x%02x\" />", model.Sw, model.Sh, bg.R, bg.G, bg.B))
-	lines = append(lines, fmt.Sprintf("<g transform=\"scale(%f) translate(0.5 0.5)\">", model.Scale))
-	for i, shape := range model.Shapes {
-		c := model.Colors[i]
-		attrs := "fill=\"#%02x%02x%02x\" fill-opacity=\"%f\""
-		attrs = fmt.Sprintf(attrs, c.R, c.G, c.B, float64(c.A)/255)
-		lines = append(lines, shape.SVG(attrs))
-	}
-	lines = append(lines, "</g>")
-	lines = append(lines, "</svg>")
-	return strings.Join(lines, "\n")
-}
-
-func (model *Model) Add(shape Shape, alpha int) {
-	before := copyRGBA(model.Current)
-	lines := shape.Rasterize()
-	color := computeColor(model.Target, model.Current, lines, alpha)
-	drawLines(model.Current, color, lines)
-	score := differencePartial(model.Target, before, model.Current, model.Score, lines)
-
-	model.Score = score
-	model.Shapes = append(model.Shapes, shape)
-	model.Colors = append(model.Colors, color)
-	model.Scores = append(model.Scores, score)
-
-	model.Context.SetRGBA255(color.R, color.G, color.B, color.A)
-	shape.Draw(model.Context, model.Scale)
-}
-
-func (model *Model) Step(shapeType ShapeType, alpha, repeat int) int {
-	state := model.runWorkers(shapeType, alpha, 1000, 100, 16)
-	// state = HillClimb(state, 1000).(*State)
-	model.Add(state.Shape, state.Alpha)
-
-	for i := 0; i < repeat; i++ {
-		state.Worker.Init(model.Current, model.Score)
-		a := state.Energy()
-		state = HillClimb(state, 100).(*State)
-		b := state.Energy()
-		if a == b {
-			break
-		}
-		model.Add(state.Shape, state.Alpha)
-	}
-
-	// for _, w := range model.Workers[1:] {
-	// 	model.Workers[0].Heatmap.AddHeatmap(w.Heatmap)
-	// }
-	// SavePNG("heatmap.png", model.Workers[0].Heatmap.Image(0.5))
-
-	counter := 0
-	for _, worker := range model.Workers {
-		counter += worker.Counter
-	}
-	return counter
-}
-
-func (model *Model) runWorkers(t ShapeType, a, n, age, m int) *State {
-	wn := len(model.Workers)
-	ch := make(chan *State, wn)
-	wm := m / wn
-	if m%wn != 0 {
-		wm++
-	}
-	for i := 0; i < wn; i++ {
-		worker := model.Workers[i]
-		worker.Init(model.Current, model.Score)
-		go model.runWorker(worker, t, a, n, age, wm, ch)
-	}
-	var bestEnergy float64
-	var bestState *State
-	for i := 0; i < wn; i++ {
-		state := <-ch
-		energy := state.Energy()
-		if i == 0 || energy < bestEnergy {
-			bestEnergy = energy
-			bestState = state
-		}
-	}
-	return bestState
-}
-
-func (model *Model) runWorker(worker *Worker, t ShapeType, a, n, age, m int, ch chan *State) {
-	ch <- worker.BestHillClimbState(t, a, n, age, m)
-}
diff --git a/vendor/github.com/fogleman/primitive/primitive/optimize.go b/vendor/github.com/fogleman/primitive/primitive/optimize.go
deleted file mode 100644
index e15d2b6..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/optimize.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package primitive
-
-import (
-	"math"
-	"math/rand"
-)
-
-type Annealable interface {
-	Energy() float64
-	DoMove() interface{}
-	UndoMove(interface{})
-	Copy() Annealable
-}
-
-func HillClimb(state Annealable, maxAge int) Annealable {
-	state = state.Copy()
-	bestState := state.Copy()
-	bestEnergy := state.Energy()
-	step := 0
-	for age := 0; age < maxAge; age++ {
-		undo := state.DoMove()
-		energy := state.Energy()
-		if energy >= bestEnergy {
-			state.UndoMove(undo)
-		} else {
-			// fmt.Printf("step: %d, energy: %.6f\n", step, energy)
-			bestEnergy = energy
-			bestState = state.Copy()
-			age = -1
-		}
-		step++
-	}
-	return bestState
-}
-
-func PreAnneal(state Annealable, iterations int) float64 {
-	state = state.Copy()
-	previous := state.Energy()
-	var total float64
-	for i := 0; i < iterations; i++ {
-		state.DoMove()
-		energy := state.Energy()
-		total += math.Abs(energy - previous)
-		previous = energy
-	}
-	return total / float64(iterations)
-}
-
-func Anneal(state Annealable, maxTemp, minTemp float64, steps int) Annealable {
-	factor := -math.Log(maxTemp / minTemp)
-	state = state.Copy()
-	bestState := state.Copy()
-	bestEnergy := state.Energy()
-	previousEnergy := bestEnergy
-	for step := 0; step < steps; step++ {
-		pct := float64(step) / float64(steps-1)
-		temp := maxTemp * math.Exp(factor*pct)
-		undo := state.DoMove()
-		energy := state.Energy()
-		change := energy - previousEnergy
-		if change > 0 && math.Exp(-change/temp) < rand.Float64() {
-			state.UndoMove(undo)
-		} else {
-			previousEnergy = energy
-			if energy < bestEnergy {
-				// pct := float64(step*100) / float64(steps)
-				// fmt.Printf("step: %d of %d (%.1f%%), temp: %.3f, energy: %.6f\n",
-				// 	step, steps, pct, temp, energy)
-				bestEnergy = energy
-				bestState = state.Copy()
-			}
-		}
-	}
-	return bestState
-}
diff --git a/vendor/github.com/fogleman/primitive/primitive/polygon.go b/vendor/github.com/fogleman/primitive/primitive/polygon.go
deleted file mode 100644
index dee3a6c..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/polygon.go
+++ /dev/null
@@ -1,122 +0,0 @@
-package primitive
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/fogleman/gg"
-	"github.com/golang/freetype/raster"
-)
-
-type Polygon struct {
-	Worker *Worker
-	Order  int
-	Convex bool
-	X, Y   []float64
-}
-
-func NewRandomPolygon(worker *Worker, order int, convex bool) *Polygon {
-	rnd := worker.Rnd
-	x := make([]float64, order)
-	y := make([]float64, order)
-	x[0] = rnd.Float64() * float64(worker.W)
-	y[0] = rnd.Float64() * float64(worker.H)
-	for i := 1; i < order; i++ {
-		x[i] = x[0] + rnd.Float64()*40 - 20
-		y[i] = y[0] + rnd.Float64()*40 - 20
-	}
-	p := &Polygon{worker, order, convex, x, y}
-	p.Mutate()
-	return p
-}
-
-func (p *Polygon) Draw(dc *gg.Context, scale float64) {
-	dc.NewSubPath()
-	for i := 0; i < p.Order; i++ {
-		dc.LineTo(p.X[i], p.Y[i])
-	}
-	dc.ClosePath()
-	dc.Fill()
-}
-
-func (p *Polygon) SVG(attrs string) string {
-	ret := fmt.Sprintf(
-		"<polygon %s points=\"",
-		attrs)
-	points := make([]string, len(p.X))
-	for i := 0; i < len(p.X); i++ {
-		points[i] = fmt.Sprintf("%f,%f", p.X[i], p.Y[i])
-	}
-
-	return ret + strings.Join(points, ",") + "\" />"
-}
-
-func (p *Polygon) Copy() Shape {
-	a := *p
-	a.X = make([]float64, p.Order)
-	a.Y = make([]float64, p.Order)
-	copy(a.X, p.X)
-	copy(a.Y, p.Y)
-	return &a
-}
-
-func (p *Polygon) Mutate() {
-	const m = 16
-	w := p.Worker.W
-	h := p.Worker.H
-	rnd := p.Worker.Rnd
-	for {
-		if rnd.Float64() < 0.25 {
-			i := rnd.Intn(p.Order)
-			j := rnd.Intn(p.Order)
-			p.X[i], p.Y[i], p.X[j], p.Y[j] = p.X[j], p.Y[j], p.X[i], p.Y[i]
-		} else {
-			i := rnd.Intn(p.Order)
-			p.X[i] = clamp(p.X[i]+rnd.NormFloat64()*16, -m, float64(w-1+m))
-			p.Y[i] = clamp(p.Y[i]+rnd.NormFloat64()*16, -m, float64(h-1+m))
-		}
-		if p.Valid() {
-			break
-		}
-	}
-}
-
-func (p *Polygon) Valid() bool {
-	if !p.Convex {
-		return true
-	}
-	var sign bool
-	for a := 0; a < p.Order; a++ {
-		i := (a + 0) % p.Order
-		j := (a + 1) % p.Order
-		k := (a + 2) % p.Order
-		c := cross3(p.X[i], p.Y[i], p.X[j], p.Y[j], p.X[k], p.Y[k])
-		if a == 0 {
-			sign = c > 0
-		} else if c > 0 != sign {
-			return false
-		}
-	}
-	return true
-}
-
-func cross3(x1, y1, x2, y2, x3, y3 float64) float64 {
-	dx1 := x2 - x1
-	dy1 := y2 - y1
-	dx2 := x3 - x2
-	dy2 := y3 - y2
-	return dx1*dy2 - dy1*dx2
-}
-
-func (p *Polygon) Rasterize() []Scanline {
-	var path raster.Path
-	for i := 0; i <= p.Order; i++ {
-		f := fixp(p.X[i%p.Order], p.Y[i%p.Order])
-		if i == 0 {
-			path.Start(f)
-		} else {
-			path.Add1(f)
-		}
-	}
-	return fillPath(p.Worker, path)
-}
diff --git a/vendor/github.com/fogleman/primitive/primitive/quadratic.go b/vendor/github.com/fogleman/primitive/primitive/quadratic.go
deleted file mode 100644
index 740d44a..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/quadratic.go
+++ /dev/null
@@ -1,100 +0,0 @@
-package primitive
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/fogleman/gg"
-	"github.com/golang/freetype/raster"
-)
-
-type Quadratic struct {
-	Worker *Worker
-	X1, Y1 float64
-	X2, Y2 float64
-	X3, Y3 float64
-	Width  float64
-}
-
-func NewRandomQuadratic(worker *Worker) *Quadratic {
-	rnd := worker.Rnd
-	x1 := rnd.Float64() * float64(worker.W)
-	y1 := rnd.Float64() * float64(worker.H)
-	x2 := x1 + rnd.Float64()*40 - 20
-	y2 := y1 + rnd.Float64()*40 - 20
-	x3 := x2 + rnd.Float64()*40 - 20
-	y3 := y2 + rnd.Float64()*40 - 20
-	width := 1.0 / 2
-	q := &Quadratic{worker, x1, y1, x2, y2, x3, y3, width}
-	q.Mutate()
-	return q
-}
-
-func (q *Quadratic) Draw(dc *gg.Context, scale float64) {
-	dc.MoveTo(q.X1, q.Y1)
-	dc.QuadraticTo(q.X2, q.Y2, q.X3, q.Y3)
-	dc.SetLineWidth(q.Width * scale)
-	dc.Stroke()
-}
-
-func (q *Quadratic) SVG(attrs string) string {
-	// TODO: this is a little silly
-	attrs = strings.Replace(attrs, "fill", "stroke", -1)
-	return fmt.Sprintf(
-		"<path %s fill=\"none\" d=\"M %f %f Q %f %f, %f %f\" stroke-width=\"%f\" />",
-		attrs, q.X1, q.Y1, q.X2, q.Y2, q.X3, q.Y3, q.Width)
-}
-
-func (q *Quadratic) Copy() Shape {
-	a := *q
-	return &a
-}
-
-func (q *Quadratic) Mutate() {
-	const m = 16
-	w := q.Worker.W
-	h := q.Worker.H
-	rnd := q.Worker.Rnd
-	for {
-		switch rnd.Intn(3) {
-		case 0:
-			q.X1 = clamp(q.X1+rnd.NormFloat64()*16, -m, float64(w-1+m))
-			q.Y1 = clamp(q.Y1+rnd.NormFloat64()*16, -m, float64(h-1+m))
-		case 1:
-			q.X2 = clamp(q.X2+rnd.NormFloat64()*16, -m, float64(w-1+m))
-			q.Y2 = clamp(q.Y2+rnd.NormFloat64()*16, -m, float64(h-1+m))
-		case 2:
-			q.X3 = clamp(q.X3+rnd.NormFloat64()*16, -m, float64(w-1+m))
-			q.Y3 = clamp(q.Y3+rnd.NormFloat64()*16, -m, float64(h-1+m))
-		case 3:
-			q.Width = clamp(q.Width+rnd.NormFloat64(), 1, 16)
-		}
-		if q.Valid() {
-			break
-		}
-	}
-}
-
-func (q *Quadratic) Valid() bool {
-	dx12 := int(q.X1 - q.X2)
-	dy12 := int(q.Y1 - q.Y2)
-	dx23 := int(q.X2 - q.X3)
-	dy23 := int(q.Y2 - q.Y3)
-	dx13 := int(q.X1 - q.X3)
-	dy13 := int(q.Y1 - q.Y3)
-	d12 := dx12*dx12 + dy12*dy12
-	d23 := dx23*dx23 + dy23*dy23
-	d13 := dx13*dx13 + dy13*dy13
-	return d13 > d12 && d13 > d23
-}
-
-func (q *Quadratic) Rasterize() []Scanline {
-	var path raster.Path
-	p1 := fixp(q.X1, q.Y1)
-	p2 := fixp(q.X2, q.Y2)
-	p3 := fixp(q.X3, q.Y3)
-	path.Start(p1)
-	path.Add2(p2, p3)
-	width := fix(q.Width)
-	return strokePath(q.Worker, path, width, raster.RoundCapper, raster.RoundJoiner)
-}
diff --git a/vendor/github.com/fogleman/primitive/primitive/raster.go b/vendor/github.com/fogleman/primitive/primitive/raster.go
deleted file mode 100644
index a5d620a..0000000
--- a/vendor/github.com/fogleman/primitive/primitive/raster.go
+++ /dev/null
@@ -1,46 +0,0 @@
-package primitive
-
-import (
-	"github.com/golang/freetype/raster"
-	"golang.org/x/image/math/fixed"
-)
-
-func fix(x float64) fixed.Int26_6 {
-	return fixed.Int26_6(x * 64)
-}
-
-func fixp(x, y float64) fixed.Point26_6 {
-	return fixed.Point26_6{fix(x), fix(y)}
-}
-
-type painter struct {
-	Lines []Scanline
-}
-
-func (p *painter) Paint(spans []raster.Span, done bool) {
-	for _, span := range spans {
-		p.Lines = append(p.Lines, Scanline{span.Y, span.X0, span.X1 - 1, span.Alpha})
-	}
-}
-
-func fillPath(worker *Worker, path raster.Path) []Scanline {
-	r := worker.Rasterizer
-	r.Clear()
-	r.UseNonZeroWinding = true
-	r.AddPath(path)
-	var p painter
-	p.Lines = worker.Lines[:0]
-	r.Rasterize(&p)
-	return p.Lines
-}
-
-func strokePath(worker *Worker, path raster.Path, width fixed.Int26_6, cr raster.Capper, jr raster.Joiner) []Scanline {
-	r := worker.Rasterizer
-	r.Clear()
-	r.UseNonZeroWinding = true
-	r.AddStroke(path, width, cr, jr)
-	var p painter
-	p.Lines = work