Merge pull request #2 from julyskies/develop

Develop

Author: peterdee

README.md

@@ -189,6 +189,12 @@ Full Fiber example is available at https://github.com/peterdee/filtering-backend
   rotated, format, processingError := brille.HueRotate(file, 278)
   ```
 
+- **Kuwahara filter**: an edge detection filter with dynamic aperture size.  Requires aperture size to be provided, but due to the perfomance reasons maximum aperture size is limited to 40. This filter is very slow, and will probably be optimized in the future:
+
+  ```golang
+  kuwahara, format, processingError := brille.KuwaharaFilter(file, 9)
+  ```
+
 - **Laplasian filter**: a static edge detection filter that uses a 3x3 kernel. It can be used to outline edges on an image:
 
   ```golang
@@ -211,10 +217,16 @@ Full Fiber example is available at https://github.com/peterdee/filtering-backend
   sepia, format, processingError := brille.Sepia(file)
   ```
 
+- **Sharpen filter**: image sharpening. Requires an ammount to be provided. Effect amount ranges from 0 to 100:
+
+  ```golang
+  sharpen, format, processingError := brille.SharpenFilter(file, 77)
+  ```
+
 - **Sobel filter**: a static edge detection filter that uses a 3x3 kernel. It can be used to outline edges on an image:
 
   ```golang
-  sobel, format, processingError := brille.Sobel(file)
+  sobel, format, processingError := brille.SobelFilter(file)
   ```
 
 - **Solarize**: solarization affects image colors, partially inversing the colors. Requires a threshold to be provided. Threshold ranges from 0 to 255:
@@ -223,6 +235,10 @@ Full Fiber example is available at https://github.com/peterdee/filtering-backend
   solarized, format, processingError := brille.Solarize(file, 99)
   ```
 
+### Environment variables
+
+- `BRILLE_JPEG_QUALITY` (`int`) - controls output quality for JPEG images, should be a number from 0 (low quality) to 100 (highest quality)
+
 ### License
 
 [MIT](./LICENSE.md)

index.go

@@ -220,6 +220,24 @@ func HueRotate(file io.Reader, angle int) (io.Reader, string, error) {
 	return encoded, format, nil
 }
 
+// aperture: 0 to 40
+func KuwaharaFilter(file io.Reader, aperture uint) (io.Reader, string, error) {
+	if file == nil {
+		return nil, "", errors.New(constants.ERROR_NO_FILE_PROVIDED)
+	}
+	aperture = utilities.MaxMin(aperture, 40, 0)
+	source, format, preparationError := utilities.PrepareSource(file)
+	if preparationError != nil {
+		return nil, "", preparationError
+	}
+	kuwahara := processing.KuwaharaFilter(source, aperture)
+	encoded, encodingError := utilities.PrepareResult(kuwahara, format)
+	if encodingError != nil {
+		return nil, "", encodingError
+	}
+	return encoded, format, nil
+}
+
 func LaplasianFilter(file io.Reader) (io.Reader, string, error) {
 	if file == nil {
 		return nil, "", errors.New(constants.ERROR_NO_FILE_PROVIDED)
@@ -300,6 +318,24 @@ func Sepia(file io.Reader) (io.Reader, string, error) {
 	return encoded, format, nil
 }
 
+// amount: 0 to 100
+func SharpenFilter(file io.Reader, amount uint) (io.Reader, string, error) {
+	if file == nil {
+		return nil, "", errors.New(constants.ERROR_NO_FILE_PROVIDED)
+	}
+	mix := float64(utilities.MaxMin(amount, 100, 0)) / 100
+	source, format, preparationError := utilities.PrepareSource(file)
+	if preparationError != nil {
+		return nil, "", preparationError
+	}
+	sharpen := processing.Sharpen(source, mix)
+	encoded, encodingError := utilities.PrepareResult(sharpen, format)
+	if encodingError != nil {
+		return nil, "", encodingError
+	}
+	return encoded, format, nil
+}
+
 func SobelFilter(file io.Reader) (io.Reader, string, error) {
 	if file == nil {
 		return nil, "", errors.New(constants.ERROR_NO_FILE_PROVIDED)

processing/kuwahara-filter.go

@@ -0,0 +1,87 @@
+package processing
+
+import (
+	"image/color"
+
+	"github.com/julyskies/brille/utilities"
+)
+
+func getAperture(axisValue, axisMax, apertureMin, apertureMax int) (int, int) {
+	start, end := 0, axisMax
+	if axisValue+apertureMin > 0 {
+		start = axisValue + apertureMin
+	}
+	if axisValue+apertureMax < axisMax {
+		end = axisValue + apertureMax
+	}
+	return start, end
+}
+
+func KuwaharaFilter(source [][]color.Color, aperture uint) [][]color.Color {
+	width, height := len(source), len(source[0])
+	destination := utilities.CreateGrid(width, height)
+	apertureHalf := int(aperture / 2)
+	apertureMinX := [4]int{-apertureHalf, 0, -apertureHalf, 0}
+	apertureMaxX := [4]int{0, apertureHalf, 0, apertureHalf}
+	apertureMinY := [4]int{-apertureHalf, -apertureHalf, 0, 0}
+	apertureMaxY := [4]int{0, 0, apertureHalf, apertureHalf}
+	for x := 0; x < width; x += 1 {
+		for y := 0; y < height; y += 1 {
+			pixelCount := [4]int{0, 0, 0, 0}
+			rValues := [4]int{0, 0, 0, 0}
+			gValues := [4]int{0, 0, 0, 0}
+			bValues := [4]int{0, 0, 0, 0}
+			maxRValue := [4]int{0, 0, 0, 0}
+			maxGValue := [4]int{0, 0, 0, 0}
+			maxBValue := [4]int{0, 0, 0, 0}
+			minRValue := [4]int{255, 255, 255, 255}
+			minGValue := [4]int{255, 255, 255, 255}
+			minBValue := [4]int{255, 255, 255, 255}
+			for i := 0; i < 4; i += 1 {
+				x2start, x2end := getAperture(x, width, apertureMinX[i], apertureMaxX[i])
+				y2start, y2end := getAperture(y, height, apertureMinY[i], apertureMaxY[i])
+				for x2 := x2start; x2 < x2end; x2 += 1 {
+					for y2 := y2start; y2 < y2end; y2 += 1 {
+						r, g, b, _ := utilities.RGBA(source[x2][y2])
+						rValues[i] += int(r)
+						gValues[i] += int(g)
+						bValues[i] += int(b)
+						if int(r) > maxRValue[i] {
+							maxRValue[i] = int(r)
+						} else if int(r) < minRValue[i] {
+							minRValue[i] = int(r)
+						}
+						if int(g) > maxGValue[i] {
+							maxGValue[i] = int(g)
+						} else if int(g) < minGValue[i] {
+							minGValue[i] = int(g)
+						}
+						if int(b) > maxBValue[i] {
+							maxBValue[i] = int(b)
+						} else if int(b) < minBValue[i] {
+							minBValue[i] = int(b)
+						}
+						pixelCount[i] += 1
+					}
+				}
+			}
+			j := 0
+			MinDifference := 10000
+			for i := 0; i < 4; i += 1 {
+				cdR := maxRValue[i] - minRValue[i]
+				cdG := maxGValue[i] - minGValue[i]
+				cdB := maxBValue[i] - minBValue[i]
+				CurrentDifference := cdR + cdG + cdB
+				if CurrentDifference < MinDifference && pixelCount[i] > 0 {
+					j = i
+					MinDifference = CurrentDifference
+				}
+			}
+			cR := uint8(rValues[j] / pixelCount[j])
+			cG := uint8(gValues[j] / pixelCount[j])
+			cB := uint8(bValues[j] / pixelCount[j])
+			destination[x][y] = color.RGBA{cR, cG, cB, 255}
+		}
+	}
+	return destination
+}

processing/sharpen.go

@@ -0,0 +1,41 @@
+package processing
+
+import (
+	"image/color"
+
+	"github.com/julyskies/brille/utilities"
+)
+
+var sharpenKernel = [3][3]int{
+	{-1, -1, -1},
+	{-1, 9, -1},
+	{-1, -1, -1},
+}
+
+func Sharpen(source [][]color.Color, mix float64) [][]color.Color {
+	width, height := len(source), len(source[0])
+	destination := utilities.CreateGrid(width, height)
+	for x := 0; x < width; x += 1 {
+		for y := 0; y < height; y += 1 {
+			sumR := 0
+			sumG := 0
+			sumB := 0
+			for i := 0; i < 3; i += 1 {
+				for j := 0; j < 3; j += 1 {
+					k := utilities.GradientPoint(x, i, width)
+					l := utilities.GradientPoint(y, j, height)
+					r, g, b, _ := utilities.RGBA(source[x+k][y+l])
+					sumR += int(r) * sharpenKernel[i][j]
+					sumG += int(g) * sharpenKernel[i][j]
+					sumB += int(b) * sharpenKernel[i][j]
+				}
+			}
+			r, g, b, alpha := utilities.RGBA(source[x][y])
+			R := utilities.MaxMin(float64(sumR)*mix+float64(r)*(1-mix), 255, 0)
+			G := utilities.MaxMin(float64(sumG)*mix+float64(g)*(1-mix), 255, 0)
+			B := utilities.MaxMin(float64(sumB)*mix+float64(b)*(1-mix), 255, 0)
+			destination[x][y] = color.RGBA{uint8(R), uint8(G), uint8(B), alpha}
+		}
+	}
+	return destination
+}

utilities/prepare-result.go

@@ -7,6 +7,8 @@ import (
 	"image/jpeg"
 	"image/png"
 	"io"
+	"os"
+	"strconv"
 )
 
 func PrepareResult(result [][]color.Color, format string) (io.Reader, error) {
@@ -18,6 +20,15 @@ func PrepareResult(result [][]color.Color, format string) (io.Reader, error) {
 		}
 	}
 
+	jpegQualityENV := os.Getenv("BRILLE_JPEG_QUALITY")
+	jpegQuality := 100
+	if jpegQualityENV != "" {
+		parsed, parsingError := strconv.Atoi(jpegQualityENV)
+		if parsingError == nil {
+			jpegQuality = MaxMin(parsed, 100, 0)
+		}
+	}
+
 	var buffer bytes.Buffer
 	writer := io.Writer(&buffer)
 	if format == "png" {
@@ -26,7 +37,13 @@ func PrepareResult(result [][]color.Color, format string) (io.Reader, error) {
 			return nil, encodingError
 		}
 	} else {
-		encodingError := jpeg.Encode(writer, nrgba.SubImage(nrgba.Rect), nil)
+		encodingError := jpeg.Encode(
+			writer,
+			nrgba.SubImage(nrgba.Rect),
+			&jpeg.Options{
+				Quality: jpegQuality,
+			},
+		)
 		if encodingError != nil {
 			return nil, encodingError
 		}