Add optimized Gaussian blur to completed filters, optimize Binary filter

Author: peterdee

README.md

@@ -4,24 +4,19 @@ Various image processing functions written in Golang
 
 This module is a base for https://github.com/julyskies/brille
 
-### Filters to add
-
-1. Bilateral filter (static / dynamic)
-2. Gaussian blur (static)
-3. Image rotation for any given angle
-
 ### Available filters
 
 These filters are ready to be used and were optimized compared to previous implementations
 
-- Binary
+- Binary **(optimized, uses WaitGroup)**
 - Box blur (dynamic)
 - Brightness
 - Contrast
 - Eight colors (color reduction filter)
 - Emboss filter (edge detection, static)
 - Flip image (horizontal, vertical)
 - Gamma correction
+- Gaussian blur (dynamic) **(optimized, uses WaitGroup)**
 - Grayscale (average, luminance)
 - Hue rotate
 - Inversion
@@ -38,7 +33,6 @@ These filters are ready to be used and were optimized compared to previous imple
 These filters are not ready yet
 
 - Bilateral filter (static / dynamic)
-- Gaussian blur (dynamic)
 - Rotate image by any given angle
 
 ### License

filters/bilateral-slow.go

@@ -0,0 +1,45 @@
+package filters
+
+import (
+	"math"
+	"runtime"
+	"sync"
+	"time"
+)
+
+func Binary(path string, threshold uint8) {
+	img, format, openMS, convertMS := open(path)
+	now := math.Round(float64(time.Now().UnixNano()) / 1000000)
+
+	pixLen := len(img.Pix)
+	threads := runtime.NumCPU()
+	pixPerThreadRaw := float64(pixLen) / float64(threads)
+	pixPerThread := int(pixPerThreadRaw + (float64(threads) - math.Mod(pixPerThreadRaw, 4.0)))
+
+	var wg sync.WaitGroup
+
+	processing := func(startIndex int) {
+		defer wg.Done()
+		endIndex := clampMax(startIndex+pixPerThread, pixLen)
+		for i := startIndex; i < endIndex; i += 4 {
+			average := uint8((int(img.Pix[i]) + int(img.Pix[i+1]) + int(img.Pix[i+2])) / 3)
+			channel := uint8(255)
+			if average < threshold {
+				channel = 0
+			}
+			img.Pix[i], img.Pix[i+1], img.Pix[i+2] = channel, channel, channel
+		}
+	}
+
+	for t := 0; t < threads; t += 1 {
+		wg.Add(1)
+		go processing(pixPerThread * t)
+	}
+
+	wg.Wait()
+
+	processMS := int(math.Round(float64(time.Now().UnixNano())/1000000) - now)
+	saveMS := save(img, format)
+	sum := openMS + convertMS + processMS + saveMS
+	println("open", openMS, "convert", convertMS, "process", processMS, "save", saveMS, "sum", sum)
+}

filters/binary-optimized.go

@@ -1,4 +1,4 @@
-package progress
+package filters
 
 import (
 	"math"
@@ -9,8 +9,39 @@ import (
 	"go-image-processing/utilities"
 )
 
-// Gaussian blur: even more faster (sync.WaitGroup) - top 1
-func GaussianBlurEMF(path string, sigma float64) {
+const K float64 = 6
+
+func clampMax[T float64 | int | uint8](value, max T) T {
+	if value > max {
+		return max
+	}
+	return value
+}
+
+func createKernel(sigma float64) []float64 {
+	dim := math.Max(3.0, K*sigma)
+	sqrtSigmaPi2 := math.Sqrt(math.Pi*2.0) * sigma
+	s2 := 2.0 * sigma * sigma
+	sum := 0.0
+	kDim := dim
+	if int(kDim)%2 == 0 {
+		kDim = dim - 1
+	}
+	kernel := make([]float64, int(kDim))
+	half := int(len(kernel) / 2)
+	i := -half
+	for j := 0; j < len(kernel); j += 1 {
+		kernel[j] = math.Exp(-float64(i*i)/(s2)) / sqrtSigmaPi2
+		sum += kernel[j]
+		i += 1
+	}
+	for k := 0; k < int(kDim); k += 1 {
+		kernel[k] /= sum
+	}
+	return kernel
+}
+
+func GaussianBlur(path string, sigma float64) {
 	if sigma < 0 {
 		sigma *= -1
 	}
@@ -75,20 +106,17 @@ func GaussianBlurEMF(path string, sigma float64) {
 		wg.Add(1)
 		go processing(pixPerThread*t, "horizontal")
 	}
-
 	wg.Wait()
 
 	// vertical
 	for t := 0; t < threads; t += 1 {
 		wg.Add(1)
 		go processing(pixPerThread*t, "vertical")
 	}
-
 	wg.Wait()
 
 	processMS := int(math.Round(float64(time.Now().UnixNano())/1000000) - now)
-	saveMS := save(img, format, 1)
+	saveMS := save(img, format)
 	sum := openMS + convertMS + processMS + saveMS
 	println("open", openMS, "convert", convertMS, "process", processMS, "save", saveMS, "sum", sum)
-	println("threads", threads)
 }

filters/binary.go

@@ -10,7 +10,6 @@ import (
 	"math"
 	"os"
 	"runtime"
-	"sync"
 	"time"
 )
 
@@ -56,48 +55,45 @@ func save(img *image.RGBA, format string, iteration int) int {
 	return int(math.Round(float64(time.Now().UnixNano())/1000000) - now)
 }
 
-func processing(path string, threshold uint8, iteration int) int {
+// Binary filter that uses channels - slightly slower than WaitGroup
+func BinaryCH(path string, threshold uint8) {
 	img, format, openMS, convertMS := open(path)
 	now := math.Round(float64(time.Now().UnixNano()) / 1000000)
 
-	sa := len(img.Pix) / 4
+	pixLen := len(img.Pix)
+	threads := runtime.NumCPU()
+	pixPerThreadRaw := float64(pixLen) / float64(threads)
+	pixPerThread := int(pixPerThreadRaw + (float64(threads) - math.Mod(pixPerThreadRaw, 4.0)))
 
-	var wg sync.WaitGroup
-	wg.Add(4)
-
-	process := func(startIndex, endIndex int, threshold uint8, pixels *[]uint8) {
-		defer wg.Done()
-		pxs := *pixels
+	processing := func(startIndex int, ch chan int, thread int) {
+		endIndex := clampMax(startIndex+pixPerThread, pixLen)
 		for i := startIndex; i < endIndex; i += 4 {
-			average := uint8((int(pxs[i]) + int(pxs[i+1]) + int(pxs[i+2])) / 3)
+			average := uint8((int(img.Pix[i]) + int(img.Pix[i+1]) + int(img.Pix[i+2])) / 3)
 			channel := uint8(255)
 			if average < threshold {
 				channel = 0
 			}
-			pxs[i], pxs[i+1], pxs[i+2] = channel, channel, channel
+			img.Pix[i], img.Pix[i+1], img.Pix[i+2] = channel, channel, channel
 		}
+		ch <- thread
 	}
 
-	go process(0, sa, threshold, &img.Pix)
-	// go process(sa, len(img.Pix), threshold, &img.Pix)
-	go process(sa, sa*2, threshold, &img.Pix)
-	go process(sa*2, sa*3, threshold, &img.Pix)
-	go process(sa*3, len(img.Pix), threshold, &img.Pix)
-
-	wg.Wait()
+	ch := make(chan int)
+	done := make([]int, 0)
+	for t := 0; t < threads; t += 1 {
+		go processing(pixPerThread*t, ch, t)
+	}
+	for {
+		result := <-ch
+		done = append(done, result)
+		if len(done) == threads {
+			close(ch)
+			break
+		}
+	}
 
 	processMS := int(math.Round(float64(time.Now().UnixNano())/1000000) - now)
-	saveMS := save(img, format, iteration)
+	saveMS := save(img, format, 1)
 	sum := openMS + convertMS + processMS + saveMS
-	// println("f open", openMS, "convert", convertMS, "process", processMS, "save", saveMS, "sum", sum)
-	return sum
-}
-
-func BinaryEF(path string, threshold uint8) {
-	iterations := 100
-	total := 0
-	for i := 0; i < iterations; i += 1 {
-		total += processing(path, threshold, i)
-	}
-	println("avg", total/iterations, "CPUs:", runtime.NumCPU())
+	println("f open", openMS, "convert", convertMS, "process", processMS, "save", saveMS, "sum", sum)
 }

in-progress/gaussian-blur-emf.go renamed to filters/gaussian-blur-optimized.go

@@ -8,8 +8,8 @@ import (
 	"go-image-processing/utilities"
 )
 
-// Gaussian blur: different approach faster (channels) - worst performance
-func GaussianBlurDAF(path string, sigma float64) {
+// Gaussian blur that uses channels - slower version
+func GaussianBlurCHSlow(path string, sigma float64) {
 	if sigma < 0 {
 		sigma *= -1
 	}