optimize: make more funcs as lib

Author: fumiama

effects.go

@@ -1,47 +1,48 @@
 package gg
 
-// Brightness 调整亮度 范围：±100%
-func (dc *Context) Brightness(per int) {
-	if per == 0 {
+import (
+	"image"
+	"math"
+
+	"github.com/disintegration/imaging"
+)
+
+// AdjustBrightness 调整亮度 范围：±100%
+func (dc *Context) AdjustBrightness(s float64) {
+	if math.Abs(s) < 0.001 {
+		return
+	}
+	dc.im = (*image.RGBA)(imaging.AdjustBrightness(dc.im, s))
+}
+
+// AdjustContrast 调整对比度 范围：±100%
+func (dc *Context) AdjustContrast(s float64) {
+	if math.Abs(s) < 0.001 {
 		return
 	}
-	per = clamp(per, -100, 100)
-	gain := 255 * per / 100
-	for i, v := range dc.im.Pix {
-		if i%4 == 3 { // alpha
-			continue
-		}
-		dc.im.Pix[i] = uint8(clamp(int(v)+gain, 0, 255))
+	dc.im = (*image.RGBA)(imaging.AdjustContrast(dc.im, s))
+}
+
+// AdjustContrast 调整饱和度 范围：±100%
+func (dc *Context) AdjustSaturation(s float64) {
+	if math.Abs(s) < 0.001 {
+		return
 	}
+	dc.im = (*image.RGBA)(imaging.AdjustSaturation(dc.im, s))
 }
 
-// Contrast 调整对比度 范围：±100%
-func (dc *Context) Contrast(per int) {
-	if per == 0 {
+// Sharpen 锐化 范围：±100%
+func (dc *Context) Sharpen(s float64) {
+	if math.Abs(s) < 0.001 {
 		return
 	}
-	per = clamp(per, -100, 100) + 100
-	switch {
-	case 0 <= per && per < 100: // 损益
-		gain := per
-		for i, v := range dc.im.Pix {
-			if i%4 == 3 { // alpha
-				continue
-			}
-			dc.im.Pix[i] = uint8(clamp(int(v)*gain/100, 0, 255))
-		}
-	case 100 < per && per <= 200: // 增益
-		gain := 200 - per
-		if gain == 0 {
-			gain = 1
-		}
-		for i, v := range dc.im.Pix {
-			if i%4 == 3 { // alpha
-				continue
-			}
-			dc.im.Pix[i] = uint8(clamp(int(v)*100/gain, 0, 255))
-		}
-	default:
-		panic("unreachable")
+	dc.im = (*image.RGBA)(imaging.Sharpen(dc.im, s))
+}
+
+// Blur 模糊图像 正数
+func (dc *Context) Blur(s float64) {
+	if math.Abs(s) < 0.001 {
+		return
 	}
+	dc.im = (*image.RGBA)(imaging.Blur(dc.im, s))
 }

effects_test.go

@@ -12,12 +12,12 @@ func TestBrightness(t *testing.T) {
 		t.Fatal(err)
 	}
 	dc := NewContextForImage(im)
-	dc.Brightness(-50)
+	dc.AdjustBrightness(-50)
 	if err := saveImage(dc, "TestBrightness-50"); err != nil {
 		t.Fatal(err)
 	}
 	checkHash(t, dc, "<gg.Context 30e0b039be47de836a9fb4c8b9825ce8>")
-	dc.Brightness(70) // 70-50=20
+	dc.AdjustBrightness(70) // 70-50=20
 	if err := saveImage(dc, "TestBrightness+20"); err != nil {
 		t.Fatal(err)
 	}
@@ -30,12 +30,12 @@ func TestContrast(t *testing.T) {
 		t.Fatal(err)
 	}
 	dc := NewContextForImage(im)
-	dc.Contrast(-50)
+	dc.AdjustContrast(-50)
 	if err := saveImage(dc, "TestContrast-50"); err != nil {
 		t.Fatal(err)
 	}
 	checkHash(t, dc, "<gg.Context e6f161e094f0d95603aad891c51c0b6b>")
-	dc.Contrast(100)
+	dc.AdjustContrast(100)
 	if err := saveImage(dc, "TestContrast+100"); err != nil {
 		t.Fatal(err)
 	}

image.go

@@ -60,3 +60,23 @@ func GetImageWxH(path string) (int, int, error) {
 	sz, _, err := imgsz.DecodeSize(f)
 	return sz.Width, sz.Height, err
 }
+
+// LimitImageBounds returns resized image that newW < w and newH < h, while keeping the W/H ratio.
+//
+// LimitImageBounds 返回在保持宽高比的条件下，小于 w x h 的新 bound。
+func ImageBoundsBelow(b image.Rectangle, w, h int) image.Rectangle {
+	width := b.Dx()
+	height := b.Dy()
+	dstw, dsth := width, height
+	if dstw > w {
+		dstw = w
+		ratio := float64(dstw) / float64(width)
+		dsth *= int(float64(height) * ratio)
+	}
+	if dsth > h {
+		dsth = h
+		ratio := float64(dsth) / float64(height)
+		dstw = int(float64(width) * ratio)
+	}
+	return image.Rect(0, 0, dstw, dsth)
+}

kmeans.go

@@ -60,20 +60,8 @@ func newKMeansImage(img image.Image, k uint16) kmeansImage {
 		ki.gpuInit()
 	}
 	if !ki.canUseGPU {
-		width := img.Bounds().Dx()
-		height := img.Bounds().Dy()
-		dstw, dsth := width, height
-		if dstw > 512 {
-			dstw = 512
-			ratio := float64(dstw) / float64(width)
-			dsth *= int(float64(height) * ratio)
-		}
-		if dsth > 512 {
-			dsth = 512
-			ratio := float64(dsth) / float64(height)
-			dstw = int(float64(width) * ratio)
-		}
-		ki.bounds = image.Rect(0, 0, dstw, dsth)
+		ki.bounds = ImageBoundsBelow(img.Bounds(), 512, 512)
+		dstw, dsth := ki.bounds.Dx(), ki.bounds.Dy()
 		rgbaimg = (*image.RGBA)(imaging.Resize(img, dstw, dsth, imaging.Lanczos))
 		pixels = unsafe.Slice(
 			(*color.RGBA)(unsafe.Pointer(unsafe.SliceData(rgbaimg.Pix))),

kmeans_ocl.go

@@ -2,7 +2,6 @@ package gg
 
 import (
 	_ "embed"
-	"image"
 	"image/color"
 	"math"
 	"unsafe"
@@ -40,18 +39,8 @@ func init() {
 func (ki *kmeansImage) gpuInit() {
 	width := ki.bounds.Dx()
 	height := ki.bounds.Dy()
-	dstw, dsth := width, height
-	if dstw > 512 {
-		dstw = 512
-		ratio := float64(dstw) / float64(width)
-		dsth *= int(float64(height) * ratio)
-	}
-	if dsth > 512 {
-		dsth = 512
-		ratio := float64(dsth) / float64(height)
-		dstw = int(float64(width) * ratio)
-	}
-	ki.bounds = image.Rect(0, 0, dstw, dsth)
+	ki.bounds = ImageBoundsBelow(ki.bounds, 512, 512)
+	dstw, dsth := ki.bounds.Dx(), ki.bounds.Dy()
 
 	krn1st, err := kmeansModel.KernelCreate("assign_first_iter")
 	if err != nil {

math.go

@@ -6,16 +6,3 @@ package gg
 func sq(n float64) float64 {
 	return n * n
 }
-
-// clamp controls n in [a, b]
-//
-// clamp 将 n 的范围限制在 [a, b]
-func clamp(n, a, b int) int {
-	if n > b {
-		n = b
-	}
-	if n < a {
-		n = a
-	}
-	return n
-}