Work on Gaussian blur

Author: peterdee

in-progress/gaussian-blur-da.go

@@ -15,7 +15,7 @@ func clampMax[T float64 | int | uint8](value, max T) T {
 	return value
 }
 
-// Gaussian blur: different approach (channels)
+// Gaussian blur: different approach (channels) - top 2
 func GaussianBlurDA(path string, sigma float64) {
 	if sigma < 0 {
 		sigma *= -1
@@ -97,6 +97,7 @@ func GaussianBlurDA(path string, sigma float64) {
 		result := <-ch
 		resV = append(resV, result)
 		if len(resV) == threads {
+			close(ch)
 			break
 		}
 	}

in-progress/gaussian-blur-daf.go

@@ -0,0 +1,96 @@
+package progress
+
+import (
+	"math"
+	"runtime"
+	"time"
+
+	"go-image-processing/utilities"
+)
+
+// Gaussian blur: different approach faster (channels) - worst performance
+func GaussianBlurDAF(path string, sigma float64) {
+	if sigma < 0 {
+		sigma *= -1
+	}
+	img, format, openMS, convertMS := open(path)
+	now := math.Round(float64(time.Now().UnixNano()) / 1000000)
+
+	kernel := createKernel(sigma)
+	kernelLen := len(kernel)
+	pixLen := len(img.Pix)
+	width, height := img.Rect.Max.X, img.Rect.Max.Y
+	temp := make([]uint8, len(img.Pix))
+	threads := runtime.NumCPU()
+
+	signal := make(chan struct{}, threads)
+	step := 4
+
+	processing := func(i int, direction string) {
+		x, y := getCoordinates(i/4, width)
+		sumR := 0.0
+		sumG := 0.0
+		sumB := 0.0
+		for k := 0; k < kernelLen; k += 1 {
+			var px int
+			if direction == "horizontal" {
+				px = getPixel(
+					utilities.MaxMin(x-(kernelLen/2-k), width-1, 0),
+					y,
+					width,
+				)
+				sumR += float64(img.Pix[px]) * kernel[k]
+				sumG += float64(img.Pix[px+1]) * kernel[k]
+				sumB += float64(img.Pix[px+2]) * kernel[k]
+			} else {
+				px = getPixel(
+					x,
+					utilities.MaxMin(y-(kernelLen/2-k), height-1, 0),
+					width,
+				)
+				sumR += float64(temp[px]) * kernel[k]
+				sumG += float64(temp[px+1]) * kernel[k]
+				sumB += float64(temp[px+2]) * kernel[k]
+			}
+		}
+		if direction == "horizontal" {
+			temp[i] = uint8(utilities.MaxMin(sumR, 255, 0))
+			temp[i+1] = uint8(utilities.MaxMin(sumG, 255, 0))
+			temp[i+2] = uint8(utilities.MaxMin(sumB, 255, 0))
+		} else {
+			img.Pix[i] = uint8(utilities.MaxMin(sumR, 255, 0))
+			img.Pix[i+1] = uint8(utilities.MaxMin(sumG, 255, 0))
+			img.Pix[i+2] = uint8(utilities.MaxMin(sumB, 255, 0))
+		}
+		<-signal
+	}
+
+	// horizontal
+	i := 0
+	for {
+		if i >= pixLen {
+			break
+		}
+		signal <- struct{}{}
+		go processing(i, "horizontal")
+		i += step
+	}
+
+	// vertical
+	i = 0
+	for {
+		if i >= pixLen {
+			close(signal)
+			break
+		}
+		signal <- struct{}{}
+		go processing(i, "vertical")
+		i += step
+	}
+
+	processMS := int(math.Round(float64(time.Now().UnixNano())/1000000) - now)
+	saveMS := save(img, format, 1)
+	sum := openMS + convertMS + processMS + saveMS
+	println("open", openMS, "convert", convertMS, "process", processMS, "save", saveMS, "sum", sum)
+	println("threads", threads)
+}

in-progress/gaussian-blur-ef.go

@@ -9,7 +9,7 @@ import (
 	"go-image-processing/utilities"
 )
 
-// Gaussian blur: even faster (sync.WaitGroup)
+// Gaussian blur: even faster (sync.WaitGroup) - top 3
 func GaussianBlurEF(path string, sigma float64) {
 	if sigma < 0 {
 		sigma *= -1

in-progress/gaussian-blur-emf.go

@@ -9,7 +9,7 @@ import (
 	"go-image-processing/utilities"
 )
 
-// Gaussian blur: even more faster (sync.WaitGroup)
+// Gaussian blur: even more faster (sync.WaitGroup) - top 1
 func GaussianBlurEMF(path string, sigma float64) {
 	if sigma < 0 {
 		sigma *= -1
@@ -30,7 +30,7 @@ func GaussianBlurEMF(path string, sigma float64) {
 
 	processing := func(start int, direction string) {
 		defer wg.Done()
-		end := utilities.MaxMin(start+pixPerThread, pixLen, 0)
+		end := clampMax(start+pixPerThread, pixLen)
 		for i := start; i < end; i += 4 {
 			x, y := getCoordinates(i/4, width)
 			sumR := 0.0

main.go

@@ -7,7 +7,7 @@ import (
 var FORMAT string
 
 func main() {
-	path := "images/10.jpeg"
+	path := "images/15.jpeg"
 	// img, f, openMS, convertMS := utilities.OpenFile(path)
 	// FORMAT = f
 	// now := math.Round(float64(time.Now().UnixNano()) / 1000000)
@@ -22,11 +22,13 @@ func main() {
 	// saveMS := utilities.SaveFile("gaussEF-"+name, FORMAT, gaussEF)
 	// saveMS := utilities.SaveFile("bilateral-"+name, FORMAT, bilateral)
 
-	blur := 25.0
 	// progress.BinaryEFSlices(path, 125)
+
+	blur := 10.0
 	// progress.GaussianBlur(path, blur)
-	progress.GaussianBlurDA(path, blur)
-	// progress.GaussianBlurEF(path, 25)
+	// progress.GaussianBlurDA(path, blur)
+	progress.GaussianBlurDAF(path, blur)
+	// progress.GaussianBlurEF(path, blur)
 	// progress.GaussianBlurEMF(path, blur)
 
 	/* Optimized filters */