refactored

Author: fogleman

main.go

@@ -98,7 +98,6 @@ func main() {
 	if Workers < 1 {
 		Workers = runtime.NumCPU()
 	}
-	primitive.InitPools(Workers * 2)
 
 	// read input image
 	primitive.Log(1, "reading %s\n", Input)
@@ -118,13 +117,13 @@ func main() {
 	}
 
 	// run algorithm
-	model := primitive.NewModel(input, bg, OutputSize)
+	model := primitive.NewModel(input, bg, OutputSize, Workers)
 	primitive.Log(1, "%d: t=%.3f, score=%.6f\n", 0, 0.0, model.Score)
 	start := time.Now()
 	for i := 1; i <= Number; i++ {
 		// find optimal shape and add it to the model
 		t := time.Now()
-		n := model.Step(primitive.ShapeType(Mode), Alpha, Workers)
+		n := model.Step(primitive.ShapeType(Mode), Alpha)
 		nps := primitive.NumberString(float64(n) / time.Since(t).Seconds())
 		elapsed := time.Since(start).Seconds()
 		primitive.Log(1, "%d: t=%.3f, score=%.6f, n=%d, n/s=%s\n", i, elapsed, model.Score, n, nps)
@@ -133,7 +132,7 @@ func main() {
 		for _, output := range Outputs {
 			ext := strings.ToLower(filepath.Ext(output))
 			saveFrames := strings.Contains(output, "%") && ext != ".gif"
-			saveFrames = saveFrames && i%10 == 0
+			// saveFrames = saveFrames && i%10 == 0
 			if saveFrames || i == Number {
 				path := output
 				if saveFrames {

primitive/core.go

@@ -0,0 +1,116 @@
+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])
+			br := int(b.Pix[i])
+			bg := int(b.Pix[i+1])
+			bb := int(b.Pix[i+2])
+			i += 4
+			dr := ar - br
+			dg := ag - bg
+			db := ab - bb
+			total += uint64(dr*dr + dg*dg + db*db)
+		}
+	}
+	return math.Sqrt(float64(total)/float64(w*h*3)) / 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*3))
+	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])
+			br := int(before.Pix[i])
+			bg := int(before.Pix[i+1])
+			bb := int(before.Pix[i+2])
+			ar := int(after.Pix[i])
+			ag := int(after.Pix[i+1])
+			ab := int(after.Pix[i+2])
+			i += 4
+			dr1 := tr - br
+			dg1 := tg - bg
+			db1 := tb - bb
+			dr2 := tr - ar
+			dg2 := tg - ag
+			db2 := tb - ab
+			total -= uint64(dr1*dr1 + dg1*dg1 + db1*db1)
+			total += uint64(dr2*dr2 + dg2*dg2 + db2*db2)
+		}
+	}
+	return math.Sqrt(float64(total)/float64(w*h*3)) / 255
+}

primitive/difference.go

@@ -3,31 +3,32 @@ package primitive
 import (
 	"fmt"
 	"math"
-	"math/rand"
 
 	"github.com/fogleman/gg"
 )
 
 type Ellipse struct {
-	W, H   int
+	Worker *Worker
 	X, Y   int
 	Rx, Ry int
 	Circle bool
 }
 
-func NewRandomEllipse(w, h int, rnd *rand.Rand) *Ellipse {
-	x := rnd.Intn(w)
-	y := rnd.Intn(h)
+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{w, h, x, y, rx, ry, false}
+	return &Ellipse{worker, x, y, rx, ry, false}
 }
 
-func NewRandomCircle(w, h int, rnd *rand.Rand) *Ellipse {
-	x := rnd.Intn(w)
-	y := rnd.Intn(h)
+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{w, h, x, y, r, r, true}
+	return &Ellipse{worker, x, y, r, r, true}
 }
 
 func (c *Ellipse) Draw(dc *gg.Context, scale float64) {
@@ -46,46 +47,51 @@ func (c *Ellipse) Copy() Shape {
 	return &a
 }
 
-func (c *Ellipse) Mutate(rnd *rand.Rand) {
+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+rnd.Intn(21)-10, 0, c.W-1)
-		c.Y = clampInt(c.Y+rnd.Intn(21)-10, 0, c.H-1)
+		c.X = clampInt(c.X+rnd.Intn(21)-10, 0, w-1)
+		c.Y = clampInt(c.Y+rnd.Intn(21)-10, 0, h-1)
 	case 1:
-		c.Rx = clampInt(c.Rx+rnd.Intn(21)-10, 1, c.W-1)
+		c.Rx = clampInt(c.Rx+rnd.Intn(21)-10, 1, w-1)
 		if c.Circle {
 			c.Ry = c.Rx
 		}
 	case 2:
-		c.Ry = clampInt(c.Ry+rnd.Intn(21)-10, 1, c.W-1)
+		c.Ry = clampInt(c.Ry+rnd.Intn(21)-10, 1, w-1)
 		if c.Circle {
 			c.Rx = c.Ry
 		}
 	}
 }
 
-func (c *Ellipse) Rasterize(buf []Scanline) []Scanline {
-	lines := make([]Scanline, 0, c.Ry*2)
+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 >= c.H) && (y2 < 0 || y2 >= c.H) {
+		if (y1 < 0 || y1 >= h) && (y2 < 0 || y2 >= h) {
 			continue
 		}
-		w := int(math.Sqrt(float64(c.Ry*c.Ry-dy*dy)) * aspect)
-		x1 := c.X - w
-		x2 := c.X + w
+		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 >= c.W {
-			x2 = c.W - 1
+		if x2 >= w {
+			x2 = w - 1
 		}
-		if y1 >= 0 && y1 < c.H {
+		if y1 >= 0 && y1 < h {
 			lines = append(lines, Scanline{y1, x1, x2, 0xffff})
 		}
-		if y2 >= 0 && y2 < c.H && dy > 0 {
+		if y2 >= 0 && y2 < h && dy > 0 {
 			lines = append(lines, Scanline{y2, x1, x2, 0xffff})
 		}
 	}