Optimize more linear filters

Author: peterdee

README.md

@@ -23,10 +23,10 @@ These filters are ready to be used and were optimized compared to previous imple
 - Kuwahara filter (edge detection / coloring, dynamic)
 - Laplacian filter (edge detection, static)
 - Rotate image by fixed angle (90 / 180 / 270 degrees)
-- Sepia
+- Sepia **(optimized, uses WaitGroup)**
 - Sharpen filter (dynamic)
 - Sobel filter (edge detection, static)
-- Solarize
+- Solarize **(optimized, uses WaitGroup)**
 
 ### In progress
 

filters/binary-optimized.go

@@ -13,13 +13,13 @@ func Binary(path string, threshold uint8) {
 
 	pixLen := len(img.Pix)
 	threads := runtime.NumCPU()
-	pixPerThreadRaw := float64(pixLen) / float64(threads)
-	pixPerThread := int(pixPerThreadRaw + (float64(threads) - math.Mod(pixPerThreadRaw, 4.0)))
+	pixPerThread := getPixPerThread(pixLen, threads)
 
 	var wg sync.WaitGroup
 
-	processing := func(startIndex int) {
+	processing := func(thread int) {
 		defer wg.Done()
+		startIndex := pixPerThread * thread
 		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)
@@ -33,7 +33,7 @@ func Binary(path string, threshold uint8) {
 
 	for t := 0; t < threads; t += 1 {
 		wg.Add(1)
-		go processing(pixPerThread * t)
+		go processing(t)
 	}
 
 	wg.Wait()

filters/sepia-optimized.go

@@ -0,0 +1,44 @@
+package filters
+
+import (
+	"math"
+	"runtime"
+	"sync"
+	"time"
+)
+
+func Sepia(path string) {
+	img, format, openMS, convertMS := open(path)
+	now := math.Round(float64(time.Now().UnixNano()) / 1000000)
+
+	pixLen := len(img.Pix)
+	threads := runtime.NumCPU()
+	pixPerThread := getPixPerThread(pixLen, threads)
+
+	var wg sync.WaitGroup
+
+	processing := func(thread int) {
+		defer wg.Done()
+		startIndex := pixPerThread * thread
+		endIndex := clampMax(startIndex+pixPerThread, pixLen)
+		for i := startIndex; i < endIndex; i += 4 {
+			r, g, b := img.Pix[i], img.Pix[i+1], img.Pix[i+2]
+			dR := clampMax(0.393*float64(r)+0.769*float64(g)+0.189*float64(b), 255.0)
+			dG := clampMax(0.349*float64(r)+0.686*float64(g)+0.168*float64(b), 255.0)
+			dB := clampMax(0.272*float64(r)+0.534*float64(g)+0.131*float64(b), 255.0)
+			img.Pix[i], img.Pix[i+1], img.Pix[i+2] = uint8(dR), uint8(dG), uint8(dB)
+		}
+	}
+
+	for t := 0; t < threads; t += 1 {
+		wg.Add(1)
+		go processing(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/sepia.go

@@ -19,21 +19,6 @@ var sobelVertical = [3][3]int{
 	{-1, -2, -1},
 }
 
-func getCoordinates(pixel, width int) (int, int) {
-	return pixel % width, int(math.Floor(float64(pixel) / float64(width)))
-}
-
-func getGradientPoint(axisValue, shift, axisLength int) int {
-	if (axisValue + shift) >= axisLength {
-		return axisLength - axisValue - 1
-	}
-	return shift
-}
-
-func getPixel(x, y, width int) int {
-	return ((y * width) + x) * 4
-}
-
 func Sobel(path string) {
 	img, format, openMS, convertMS := open(path)
 	now := math.Round(float64(time.Now().UnixNano()) / 1000000)

filters/sobel.go

@@ -0,0 +1,49 @@
+package filters
+
+import (
+	"math"
+	"runtime"
+	"sync"
+	"time"
+)
+
+func applySolarizeThreshold(channel, threshold uint8) uint8 {
+	if channel < threshold {
+		return 255 - channel
+	}
+	return channel
+}
+
+func Solarize(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()
+	pixPerThread := getPixPerThread(pixLen, threads)
+
+	var wg sync.WaitGroup
+
+	processing := func(thread int) {
+		defer wg.Done()
+		startIndex := pixPerThread * thread
+		endIndex := clampMax(startIndex+pixPerThread, pixLen)
+		for i := startIndex; i < endIndex; i += 4 {
+			img.Pix[i] = applySolarizeThreshold(img.Pix[i], threshold)
+			img.Pix[i+1] = applySolarizeThreshold(img.Pix[i+1], threshold)
+			img.Pix[i+2] = applySolarizeThreshold(img.Pix[i+2], threshold)
+		}
+	}
+
+	for t := 0; t < threads; t += 1 {
+		wg.Add(1)
+		go processing(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/solarize-optimized.go

@@ -12,6 +12,26 @@ import (
 	"time"
 )
 
+func getCoordinates(pixel, width int) (int, int) {
+	return pixel % width, int(math.Floor(float64(pixel) / float64(width)))
+}
+
+func getGradientPoint(axisValue, shift, axisLength int) int {
+	if (axisValue + shift) >= axisLength {
+		return axisLength - axisValue - 1
+	}
+	return shift
+}
+
+func getPixel(x, y, width int) int {
+	return ((y * width) + x) * 4
+}
+
+func getPixPerThread(pixLen, threads int) int {
+	pixPerThreadRaw := float64(pixLen) / float64(threads)
+	return int(pixPerThreadRaw + (float64(threads) - math.Mod(pixPerThreadRaw, 4.0)))
+}
+
 func open(path string) (*image.RGBA, string, int, int) {
 	now := math.Round(float64(time.Now().UnixNano()) / 1000000)
 	file, err := os.Open(path)

filters/solarize.go

@@ -5,7 +5,7 @@ import "go-image-processing/filters"
 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)
@@ -20,15 +20,15 @@ func main() {
 	// saveMS := utilities.SaveFile("gaussEF-"+name, FORMAT, gaussEF)
 	// saveMS := utilities.SaveFile("bilateral-"+name, FORMAT, bilateral)
 
-	// Done
+	/* Alternative implementations */
+
 	// progress.BinaryCH(path, 122)
-	// progress.GaussianBlurCH(path, blur)
-	// progress.GaussianBlurCHSlow(path, blur)
+	// progress.GaussianBlurCH(path, 10.0)
+	// progress.GaussianBlurCHSlow(path, 10.0)
 
 	/* Optimized filters */
 
-	// filters.BilateralSlow(path, 3, 10, 15)
-	filters.Binary(path, 122)
+	// filters.Binary(path, 122)
 	// filters.BoxBlur(path, 7)
 	// filters.Brightness(path, 56)
 	// filters.Contrast(path, 225)
@@ -43,10 +43,10 @@ func main() {
 	// filters.Kuwahara(path, 4)
 	// filters.Laplacian(path)
 	// filters.RotateFixed(path, constants.ROTATE_FIXED_90)
-	// filters.Sepia(path)
+	filters.Sepia(path)
 	// filters.Sharpen(path, 92)
 	// filters.Sobel(path)
-	// filters.Solarize(path, 175)
+	// filters.Solarize(path, 100)
 
 	// sum := openMS + convertMS + processMS + saveMS
 	// println("s open", openMS, "convert", convertMS, "process", processMS, "save", saveMS, "sum", sum)