Optimize more linear filters

Author: peterdee

README.md

@@ -12,14 +12,14 @@ These filters are ready to be used and were optimized compared to previous imple
 - Box blur (dynamic)
 - Brightness
 - Contrast
-- Eight colors (color reduction filter)
+- Eight colors (color reduction filter) **(optimized, uses WaitGroup)**
 - Emboss filter (edge detection, static)
 - Flip image (horizontal, vertical)
 - Gamma correction
 - Gaussian blur (dynamic) **(optimized, uses WaitGroup)**
-- Grayscale (average, luminance)
+- Grayscale (average, luminance) **(optimized, uses WaitGroup)**
 - Hue rotate
-- Inversion
+- Inversion **(optimized, uses WaitGroup)**
 - Kuwahara filter (edge detection / coloring, dynamic)
 - Laplacian filter (edge detection, static)
 - Rotate image by fixed angle (90 / 180 / 270 degrees)

filters/eight-colors-optimized.go

@@ -0,0 +1,70 @@
+package filters
+
+import (
+	"math"
+	"runtime"
+	"sync"
+	"time"
+)
+
+type Color struct {
+	R, G, B int
+}
+
+var COLORS = [8]Color{
+	{255, 0, 0},
+	{0, 255, 0},
+	{0, 0, 255},
+	{255, 255, 0},
+	{255, 0, 255},
+	{0, 255, 255},
+	{255, 255, 255},
+	{0, 0, 0},
+}
+
+func EightColors(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 {
+			minDelta := 195076
+			var selectedColor Color
+			for j := range COLORS {
+				indexColor := COLORS[j]
+				rDifference := int(img.Pix[i]) - indexColor.R
+				gDifference := int(img.Pix[i+1]) - indexColor.G
+				bDifference := int(img.Pix[i+2]) - indexColor.B
+				delta := rDifference*rDifference + gDifference*gDifference + bDifference*bDifference
+				if delta < minDelta {
+					minDelta = delta
+					selectedColor = indexColor
+				}
+			}
+			img.Pix[i] = uint8(selectedColor.R)
+			img.Pix[i+1] = uint8(selectedColor.G)
+			img.Pix[i+2] = uint8(selectedColor.B)
+		}
+	}
+
+	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/eight-colors.go

@@ -0,0 +1,54 @@
+package filters
+
+import (
+	"math"
+	"runtime"
+	"sync"
+	"time"
+
+	"go-image-processing/constants"
+)
+
+func Grayscale(path, grayscaleType string) {
+	if grayscaleType != constants.GRAYSCALE_TYPE_AVERAGE &&
+		grayscaleType != constants.GRAYSCALE_TYPE_LUMINANCE {
+		grayscaleType = constants.GRAYSCALE_TYPE_AVERAGE
+	}
+	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 {
+			var channel uint8
+			if grayscaleType == constants.GRAYSCALE_TYPE_AVERAGE {
+				channel = uint8((int(img.Pix[i]) + int(img.Pix[i+1]) + int(img.Pix[i+2])) / 3)
+			} else {
+				channel = uint8(
+					(float64(img.Pix[i])*0.21 + float64(img.Pix[i+1])*0.72 + float64(img.Pix[i+2])*0.07),
+				)
+			}
+			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(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/grayscale-optimized.go

@@ -0,0 +1,42 @@
+package filters
+
+import (
+	"math"
+	"runtime"
+	"sync"
+	"time"
+)
+
+func Invert(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 {
+			img.Pix[i] = 255 - img.Pix[i]
+			img.Pix[i+1] = 255 - img.Pix[i+1]
+			img.Pix[i+2] = 255 - img.Pix[i+2]
+		}
+	}
+
+	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/grayscale.go

@@ -1,6 +1,9 @@
 package main
 
-import "go-image-processing/filters"
+import (
+	"go-image-processing/constants"
+	"go-image-processing/filters"
+)
 
 var FORMAT string
 
@@ -37,13 +40,13 @@ func main() {
 	// filters.Flip(path, constants.FLIP_TYPE_VERTICAL)
 	// filters.GammaCorrection(path, 0.7)
 	// filters.GaussianBlur(path, 5.2)
-	// filters.Grayscale(path, constants.GRAYSCALE_TYPE_AVERAGE)
+	filters.Grayscale(path, constants.GRAYSCALE_TYPE_LUMINANCE)
 	// filters.HueRotate(path, 252)
 	// filters.Invert(path)
 	// 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, 100)