133 lines
3.2 KiB
Go
133 lines
3.2 KiB
Go
package main
|
|
|
|
import (
|
|
"image"
|
|
"image/color"
|
|
"log"
|
|
"runtime"
|
|
"sync"
|
|
)
|
|
|
|
// job passed to goroutines. blend color from img1 and img2 at position (x, y)
|
|
type blendColorJob struct {
|
|
X int
|
|
Y int
|
|
Img1 image.Image
|
|
Img2 image.Image
|
|
}
|
|
|
|
// new color after blend, to apply at position (x, y)
|
|
type blendColorResult struct {
|
|
X int
|
|
Y int
|
|
Color color.Color
|
|
}
|
|
|
|
type blendWorkerPool struct {
|
|
CpuCores int
|
|
Jobs chan blendColorJob
|
|
Results chan blendColorResult
|
|
WorkerWG *sync.WaitGroup
|
|
ConsumerWG *sync.WaitGroup
|
|
}
|
|
|
|
func (p *blendWorkerPool) InitWorkerPool() {
|
|
p.CpuCores = runtime.NumCPU()
|
|
p.Jobs = make(chan blendColorJob, 1)
|
|
p.Results = make(chan blendColorResult, 1)
|
|
p.WorkerWG = new(sync.WaitGroup)
|
|
p.ConsumerWG = new(sync.WaitGroup)
|
|
}
|
|
|
|
// runs the pool of goroutines
|
|
func (p *blendWorkerPool) RunWorkers(outImg *image.RGBA) {
|
|
for i := 1; i < p.CpuCores; i++ {
|
|
p.WorkerWG.Add(1)
|
|
p.ConsumerWG.Add(1)
|
|
go p.BlendWorker()
|
|
go p.SetImageWorker(outImg)
|
|
}
|
|
}
|
|
|
|
// blending pixels and assigning them to the output image
|
|
func (p *blendWorkerPool) SendBlendJobs(dimensions image.Rectangle, img1 image.Image, img2 image.Image) {
|
|
for x := 0; x < dimensions.Max.X; x++ {
|
|
for y := 0; y < dimensions.Max.Y; y++ {
|
|
p.Jobs <- blendColorJob{x, y, img1, img2}
|
|
}
|
|
}
|
|
close(p.Jobs)
|
|
}
|
|
|
|
// goroutine to blend colors at position (x, y) from two images
|
|
func (p *blendWorkerPool) BlendWorker() {
|
|
defer p.WorkerWG.Done()
|
|
for j := range p.Jobs {
|
|
c1 := j.Img1.At(j.X, j.Y)
|
|
c2 := j.Img2.At(j.X, j.Y)
|
|
c3 := blendColor(c1, c2)
|
|
p.Results <- blendColorResult{j.X, j.Y, c3}
|
|
}
|
|
}
|
|
|
|
// goroutine to set the new color values at newImage position (x, y)
|
|
func (p *blendWorkerPool) SetImageWorker(newImage *image.RGBA) {
|
|
defer p.ConsumerWG.Done()
|
|
for r := range p.Results {
|
|
newImage.Set(r.X, r.Y, r.Color)
|
|
}
|
|
}
|
|
|
|
func (p *blendWorkerPool) BlendImages(img1 image.Image, img2 image.Image, out *image.RGBA) {
|
|
dimensions := dimensionsToRectangle(ConfigRegister.OutputWidth, ConfigRegister.OutputHeight)
|
|
|
|
// TODO: use a worker pool for those operations ?
|
|
// resize image
|
|
img1Resized := resize(img1)
|
|
img2Resized := resize(img2)
|
|
|
|
p.RunWorkers(out)
|
|
|
|
p.SendBlendJobs(dimensions, img1Resized, img2Resized)
|
|
|
|
// first waitgroup to wait for the results to be ready before closing the channel
|
|
p.WorkerWG.Wait()
|
|
close(p.Results)
|
|
|
|
// second waitgroup to ensure the encoding doesn't start before the goroutines are done
|
|
p.ConsumerWG.Wait()
|
|
}
|
|
|
|
func BlendImagesMain() {
|
|
log.Println("Blending the images...")
|
|
|
|
// output image, ready to receive pixel values
|
|
dimensions := dimensionsToRectangle(ConfigRegister.OutputWidth, ConfigRegister.OutputHeight)
|
|
outImg := image.NewRGBA(dimensions)
|
|
|
|
for i := 1; i < ConfigRegister.Amount; i++ {
|
|
// get two random images and load them
|
|
var img1 image.Image
|
|
if ConfigRegister.BaseImage != "" && i == 1 {
|
|
img1 = loadImage(ConfigRegister.BaseImage)
|
|
} else {
|
|
if i != 1 {
|
|
img1 = loadImage("output.jpg")
|
|
} else {
|
|
img1 = loadImage(getRandomImage())
|
|
}
|
|
}
|
|
|
|
img2 := loadImage(getRandomImage())
|
|
|
|
// pool of workers unionizing, ready to blend a new picture using the power of friendship
|
|
var pool blendWorkerPool
|
|
pool.InitWorkerPool()
|
|
|
|
// main blending routine
|
|
pool.BlendImages(img1, img2, outImg)
|
|
|
|
encodeImage(outImg)
|
|
}
|
|
}
|