Merge pull request #6 from DavidEsdrs/feat/blur

feat/blur

Author: DavidEsdrs

configs/configs.go

@@ -28,6 +28,8 @@ type Config struct {
 	TurnRight bool
 	Crop      string
 	Overlay   string
+	BlurSize  int
+	Sigma     float64
 
 	// Resize
 	NearestNeighbor bool
@@ -182,6 +184,11 @@ func (config *Config) ParseConfig(logger logger.Logger, inputImg image.Image) (*
 		f := filters.NewTurnRightFilter()
 		invoker.AddProcess(f)
 	}
+	if config.BlurSize > 0 {
+		logger.LogProcess("Adding blur")
+		f, _ := filters.NewBlurFilter(logger, config.Sigma, config.BlurSize)
+		invoker.AddProcess(f)
+	}
 
 	return &invoker, nil
 }

filters/blur.go

@@ -0,0 +1,77 @@
+package filters
+
+import (
+	"image/color"
+
+	"github.com/DavidEsdrs/image-processing/logger"
+	"github.com/DavidEsdrs/image-processing/utils"
+)
+
+type BlurFilter struct {
+	l          logger.Logger
+	sigma      float64
+	kernelSize int // this will define how blurry the image is
+	kernel     [][]float64
+}
+
+func NewBlurFilter(l logger.Logger, sigma float64, kernelSize int) (BlurFilter, error) {
+	kernel := utils.GaussianKernel(kernelSize, sigma)
+	bf := BlurFilter{l: l, sigma: sigma, kernelSize: kernelSize, kernel: kernel}
+	return bf, nil
+}
+
+func (bf BlurFilter) Execute(tensor *[][]color.Color) error {
+	height := len(*tensor)
+	width := len((*tensor)[0])
+
+	copy := make([][]color.Color, height)
+	for i := range copy {
+		copy[i] = append(copy[i], (*tensor)[i]...)
+	}
+
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			_, _, _, a := (*tensor)[y][x].RGBA()
+			r, g, b := bf.getValuesForPixel(tensor, &copy, x, y)
+			(*tensor)[y][x] = color.RGBA{
+				R: r,
+				G: g,
+				B: b,
+				A: uint8(a >> 8),
+			}
+		}
+	}
+
+	return nil
+}
+
+func (bf *BlurFilter) getValuesForPixel(tensor *[][]color.Color, copy *[][]color.Color, startX, startY int) (r, g, b uint8) {
+	height := len(*tensor)
+	width := len((*tensor)[0])
+
+	var rnew uint8
+	var gnew uint8
+	var bnew uint8
+
+	for y := startY; y < startY+bf.kernelSize && y < height; y++ {
+		for x := startX; x < startX+bf.kernelSize && x < width; x++ {
+			r, g, b, _ := (*copy)[y][x].RGBA()
+
+			rc := uint8(r >> 8)
+			gc := uint8(g >> 8)
+			bc := uint8(b >> 8)
+
+			w := bf.kernel[y-startY][x-startX]
+
+			convertedR := float64(rc) * w
+			convertedG := float64(gc) * w
+			convertedB := float64(bc) * w
+
+			rnew += uint8(convertedR)
+			gnew += uint8(convertedG)
+			bnew += uint8(convertedB)
+		}
+	}
+
+	return rnew, gnew, bnew
+}

main.go

@@ -123,6 +123,8 @@ func setFlags(config *configs.Config, verbose *bool, help *bool) {
 	flag.StringVar(&config.Crop, "c", "", "Crop image at given coordinates. Ex.: \"-c 0,1000,0,200\", xstart,xend,ystart,yend or \"-c 1000,200\", xend,yend (x and y start default to 0)")
 	flag.IntVar(&config.Ssr, "ssr", 0, "Subsample ratio for images YCbCr. 444 = 4:4:4, 422 = 4:2:2, 420 = 4:2:0, 440 = 4:4:0, 411 = 4:1:1, 410 = 4:1:0")
 	flag.IntVar(&config.Quality, "q", 0, "Quality of the JPEG image. 1-100")
+	flag.IntVar(&config.BlurSize, "b", 0, "How blurry the image will be")
+	flag.Float64Var(&config.Sigma, "s", 1.0, "Sigma value for blur")
 
 	// Resize
 	flag.BoolVar(&config.NearestNeighbor, "nn", false, "Apply nearest neighbor resize algorithm")

utils/utils.go

@@ -123,3 +123,31 @@ func ConvertIntoTensor(img image.Image) [][]color.Color {
 
 	return pixels
 }
+
+func GaussianKernel(size int, sigma float64) [][]float64 {
+	if size%2 == 0 {
+		size++
+	}
+
+	kernel := make([][]float64, size)
+	center := size / 2
+	sum := 0.0
+
+	for i := 0; i < size; i++ {
+		kernel[i] = make([]float64, size)
+		for j := 0; j < size; j++ {
+			x := float64(j - center)
+			y := float64(i - center)
+			kernel[i][j] = math.Exp(-(x*x+y*y)/(2*sigma*sigma)) / (2 * math.Pi * sigma * sigma)
+			sum += kernel[i][j]
+		}
+	}
+
+	for i := 0; i < size; i++ {
+		for j := 0; j < size; j++ {
+			kernel[i][j] /= sum
+		}
+	}
+
+	return kernel
+}

utils/utils_test.go

@@ -0,0 +1,12 @@
+package utils_test
+
+import (
+	"testing"
+
+	"github.com/DavidEsdrs/image-processing/utils"
+)
+
+func TestGaussianKernel(t *testing.T) {
+	res := utils.GaussianKernel(5, 1.0)
+	t.Logf("%v", res)
+}