dedicated struct to handle workers logic

This commit is contained in:
Ali Gator 2022-04-24 19:20:08 +02:00
parent f9d1395da6
commit 2360f3062b
4 changed files with 246 additions and 195 deletions

163
blend.go Normal file
View File

@ -0,0 +1,163 @@
package main
import (
"fmt"
"image"
"image/color"
"image/jpeg"
"math"
"os"
"runtime"
"sync"
)
type blendColorJob struct {
X int
Y int
Img1 image.Image
Img2 image.Image
}
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) {
dimensions := getDimensions(img1, img2)
// output image, ready to receive pixel values
outImg := image.NewRGBA(dimensions)
p.RunWorkers(outImg)
p.SendBlendJobs(dimensions, img1, img2)
// 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()
encodeImage(outImg)
}
// encode the image
func encodeImage(imgData *image.RGBA) {
out, _ := os.Create("output.jpg")
defer out.Close()
fmt.Print("Encoding the image...")
jpeg.Encode(out, imgData, nil)
fmt.Println(" Done.")
}
// convert RGBA pixel to grayscale
func grayscale(pixel color.Color) color.Color {
c := color.RGBAModel.Convert(pixel).(color.RGBA)
gray := uint8((c.R + c.G + c.B) / 3)
return color.RGBA{
R: gray,
G: gray,
B: gray,
A: c.A,
}
}
// alpha blending RGBA pixels
func blend(fc uint8, bc uint8, fa uint8, ba uint8) float64 {
// fc : foreground color
// bc : background color
// fa : foreground alpha
// ba : background alpha
// all values are alpha-premultiplied
// darken only
return math.Min(float64(fc), float64(bc))
// fucky fucky fun
// return float64((fc * fa) + (bc * (fa * 2)))
}
// blend two RGBA colors/pixels and returns a new one
func blendColor(color1 color.Color, color2 color.Color) color.Color {
oc1 := color.RGBAModel.Convert(color1).(color.RGBA)
oc2 := color.RGBAModel.Convert(color2).(color.RGBA)
r := uint8(blend(oc1.R, oc2.R, oc1.A, oc2.A))
g := uint8(blend(oc1.G, oc2.G, oc1.A, oc2.A))
b := uint8(blend(oc1.B, oc2.B, oc1.A, oc2.A))
a := oc1.A + (1-oc1.A)*oc2.A
return color.RGBA{
R: r, G: g, B: b, A: a,
}
}
// creates a new rectangle with the min height and width from both images
func getDimensions(img1 image.Image, img2 image.Image) image.Rectangle {
// get dimensions for both images
size1 := img1.Bounds().Size()
size2 := img2.Bounds().Size()
// final image sized from lowest width and height
width := int(math.Min(float64(size1.X), float64(size2.X)))
height := int(math.Min(float64(size1.Y), float64(size2.Y)))
// the dimensions, as Points, of the output image
upLeft := image.Point{0, 0}
lowRight := image.Point{width, height}
return image.Rectangle{upLeft, lowRight}
}

62
fs.go Normal file
View File

@ -0,0 +1,62 @@
package main
import (
"image"
"log"
"math/rand"
"os"
"path/filepath"
"strings"
"time"
)
// load an image from a file into an Image value
func loadImage(filename string) image.Image {
img, err := os.Open(filename)
if err != nil {
log.Fatal(err)
}
defer img.Close()
imgData, _, err := image.Decode(img)
if err != nil {
log.Fatal(err)
}
return imgData
}
// Walk through a folder recursively and returns a list of image paths
func getImagesList(path string) []string {
var imgs []string
err := filepath.Walk(path,
func(path string, info os.FileInfo, err error) error {
ext := strings.ToLower(filepath.Ext(path))
if err != nil {
return err
}
if ext == ".jpg" || ext == ".png" {
imgs = append(imgs, path)
}
return nil
})
if err != nil {
log.Println(err)
}
return imgs
}
// Randomly choose x number of image from a given folder
func getRandomImages(number int) []string {
rand.Seed(time.Now().UnixNano())
var images []string
dir := getImagesList("/home/gator/Photos/")
for i := 0; i < number; i++ {
index := rand.Intn(len(dir))
images = append(images, dir[index])
}
return images
}

200
main.go
View File

@ -1,208 +1,18 @@
package main package main
import ( import (
"fmt"
"image"
"image/color"
"image/jpeg"
_ "image/jpeg" _ "image/jpeg"
_ "image/png" _ "image/png"
"log"
"math"
"math/rand"
"os"
"path/filepath"
"runtime"
"strings"
"sync"
"time"
) )
// goroutine to blend colors at position (x, y) from two images
func blendWorker(jobs <-chan blendColorJob, results chan<- blendColorResult, wg *sync.WaitGroup) {
defer wg.Done()
for j := range jobs {
c1 := j.Img1.At(j.X, j.Y)
c2 := j.Img2.At(j.X, j.Y)
c3 := blendColor(c1, c2)
results <- blendColorResult{j.X, j.Y, c3}
}
}
// goroutine to set the new color values at newImage position (x, y)
func setImageWorker(results <-chan blendColorResult, newImage *image.RGBA, wg *sync.WaitGroup) {
defer wg.Done()
for r := range results {
newImage.Set(r.X, r.Y, r.Color)
}
}
// convert RGBA pixel to grayscale
func grayscale(pixel color.Color) color.Color {
c := color.RGBAModel.Convert(pixel).(color.RGBA)
gray := uint8((c.R + c.G + c.B) / 3)
return color.RGBA{
R: gray,
G: gray,
B: gray,
A: c.A,
}
}
// alpha blending RGBA pixels
func blend(fc uint8, bc uint8, fa uint8, ba uint8) float64 {
// fc : foreground color
// bc : background color
// fa : foreground alpha
// ba : background alpha
// all values are alpha-premultiplied
// darken only
return math.Min(float64(fc), float64(bc))
// fucky fucky fun
// return float64((fc * fa) + (bc * (fa * 2)))
}
// blend two RGBA colors/pixels and returns a new one
func blendColor(color1 color.Color, color2 color.Color) color.Color {
oc1 := color.RGBAModel.Convert(color1).(color.RGBA)
oc2 := color.RGBAModel.Convert(color2).(color.RGBA)
r := uint8(blend(oc1.R, oc2.R, oc1.A, oc2.A))
g := uint8(blend(oc1.G, oc2.G, oc1.A, oc2.A))
b := uint8(blend(oc1.B, oc2.B, oc1.A, oc2.A))
a := oc1.A + (1-oc1.A)*oc2.A
return color.RGBA{
R: r, G: g, B: b, A: a,
}
}
// load an image from a file into an Image value
func loadImage(filename string) image.Image {
img, err := os.Open(filename)
if err != nil {
log.Fatal(err)
}
defer img.Close()
imgData, _, err := image.Decode(img)
if err != nil {
log.Fatal(err)
}
return imgData
}
// Walk through a folder recursively and returns a list of image paths
func getImagesList(path string) []string {
var imgs []string
err := filepath.Walk(path,
func(path string, info os.FileInfo, err error) error {
ext := strings.ToLower(filepath.Ext(path))
if err != nil {
return err
}
if ext == ".jpg" || ext == ".png" {
imgs = append(imgs, path)
}
return nil
})
if err != nil {
log.Println(err)
}
return imgs
}
// Randomly choose x number of image from a given folder
func getRandomImages(number int) []string {
rand.Seed(time.Now().UnixNano())
var images []string
dir := getImagesList("/home/gator/Photos/")
for i := 0; i < number; i++ {
index := rand.Intn(len(dir))
images = append(images, dir[index])
}
return images
}
// creates a new rectangle with the min height and width from both images
func getDimensions(img1 image.Image, img2 image.Image) image.Rectangle {
// get dimensions for both images
size1 := img1.Bounds().Size()
size2 := img2.Bounds().Size()
// final image sized from lowest width and height
width := int(math.Min(float64(size1.X), float64(size2.X)))
height := int(math.Min(float64(size1.Y), float64(size2.Y)))
// the dimensions, as Points, of the output image
upLeft := image.Point{0, 0}
lowRight := image.Point{width, height}
return image.Rectangle{upLeft, lowRight}
}
type blendColorJob struct {
X int
Y int
Img1 image.Image
Img2 image.Image
}
type blendColorResult struct {
X int
Y int
Color color.Color
}
func main() { func main() {
cpu := runtime.NumCPU()
// channels
jobs := make(chan blendColorJob, 1)
results := make(chan blendColorResult, 1)
// waitgroups
wgWorker := new(sync.WaitGroup)
wgConsumer := new(sync.WaitGroup)
// get two random images and load them // get two random images and load them
imgs := getRandomImages(2) imgs := getRandomImages(2)
// imData1 := loadImage("assets/moutons.jpg") img1 := loadImage(imgs[0])
// imData2 := loadImage("assets/lavande.jpg") img2 := loadImage(imgs[1])
imData1 := loadImage(imgs[0])
imData2 := loadImage(imgs[1])
dimensions := getDimensions(imData1, imData2) var pool blendWorkerPool
pool.InitWorkerPool()
// output image, ready to receive pixel values pool.BlendImages(img1, img2)
outImg := image.NewRGBA(dimensions)
out, _ := os.Create("output.jpg")
defer out.Close()
for i := 1; i < cpu; i++ {
wgConsumer.Add(1)
wgWorker.Add(1)
go blendWorker(jobs, results, wgWorker)
go setImageWorker(results, outImg, wgConsumer)
}
// blending pixels and assigning them to the output image
for x := 0; x < dimensions.Max.X; x++ {
for y := 0; y < dimensions.Max.Y; y++ {
jobs <- blendColorJob{x, y, imData1, imData2}
}
}
close(jobs)
// first waitgroup to wait for the results to be ready before closing the channel
wgWorker.Wait()
close(results)
// second waitgroup to ensure the encoding doesn't start before the goroutines are done
wgConsumer.Wait()
fmt.Print("Encoding the image...")
jpeg.Encode(out, outImg, nil)
fmt.Println(" Done.")
} }

16
main_test.go Normal file
View File

@ -0,0 +1,16 @@
package main
import (
"testing"
)
func TestMain(t *testing.T) {
img1 := loadImage("assets/moutons.jpg")
img2 := loadImage("assets/lavande.jpg")
var pool blendWorkerPool
pool.InitWorkerPool()
pool.BlendImages(img1, img2)
}