Optional face detection with gocv

.travis.yml

@@ -29,6 +29,10 @@ before_install:
 #  - sudo apt-get update -qq
 #  - sudo apt-get install libcv-dev libopencv-dev libopencv-contrib-dev libhighgui-dev libopencv-photo-dev libopencv-imgproc-dev libopencv-stitching-dev libopencv-superres-dev libopencv-ts-dev libopencv-videostab-dev
 
+install:
+# It's complicated to get OpenCV built on each platform, so exclude the OpenCV-based detector and its dependencies this way.
+  - go get -t $(go list ./... | grep -v gocv | xargs)
+
 script:
   - go test -v -tags ci ./...
   - if [[ $TRAVIS_GO_VERSION == 1.9* ]]; then $GOPATH/bin/goveralls -service=travis-ci; fi

debug.go

@@ -41,12 +41,94 @@ import (
 	"path/filepath"
 )
 
-func debugOutput(debug bool, img *image.RGBA, debugType string) {
-	if debug {
-		writeImage("png", img, "./smartcrop_"+debugType+".png")
+// debugImage carries debug output image and has methods for updating and writing it
+type DebugImage struct {
+	img          *image.RGBA
+	colors       []color.RGBA
+	nextColorIdx int
+}
+
+func NewDebugImage(bounds image.Rectangle) *DebugImage {
+	di := DebugImage{}
+
+	// Set up the actual image
+	di.img = image.NewRGBA(bounds)
+	for x := bounds.Min.X; x < bounds.Max.X; x++ {
+		for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+			di.img.Set(x, y, color.Black)
+		}
+	}
+
+	// Set up an array of colors used for debug outputs
+	di.colors = []color.RGBA{
+		{0, 255, 0, 255},   // default edges
+		{255, 0, 0, 255},   // default skin
+		{0, 0, 255, 255},   // default saturation
+		{255, 128, 0, 255}, // a few extra...
+		{128, 0, 128, 255},
+		{64, 255, 255, 255},
+		{255, 64, 255, 255},
+		{255, 255, 64, 255},
+		{255, 255, 255, 255},
+	}
+	di.nextColorIdx = 0
+	return &di
+}
+
+func (di *DebugImage) popNextColor() color.RGBA {
+	c := di.colors[di.nextColorIdx]
+	di.nextColorIdx++
+
+	// Wrap around if necessary (if someone ever implements and sets a tenth detector)
+	if di.nextColorIdx >= len(di.colors) {
+		di.nextColorIdx = 0
+	}
+	return c
+}
+
+func scaledColorComponent(factor uint8, oldComponent uint8, newComponent uint8) uint8 {
+	if factor < 1 {
+		return oldComponent
+	}
+
+	return uint8(bounds(((float64(factor)/255.0*float64(newComponent))+float64(oldComponent))/2.0) * 2.0)
+}
+
+func (di *DebugImage) AddDetected(d [][]uint8) {
+	baseColor := di.popNextColor()
+
+	minX := di.img.Bounds().Min.X
+	minY := di.img.Bounds().Min.Y
+
+	maxX := di.img.Bounds().Max.X
+	maxY := di.img.Bounds().Max.Y
+	if maxX > len(d) {
+		maxX = len(d)
+	}
+	if maxY > len(d[0]) {
+		maxY = len(d[0])
+	}
+
+	for x := minX; x < maxX; x++ {
+		for y := minY; y < maxY; y++ {
+			if d[x][y] > 0 {
+				c := di.img.RGBAAt(x, y)
+				nc := color.RGBA{}
+				nc.R = scaledColorComponent(d[x][y], c.R, baseColor.R)
+				nc.G = scaledColorComponent(d[x][y], c.G, baseColor.G)
+				nc.B = scaledColorComponent(d[x][y], c.B, baseColor.B)
+				nc.A = 255
+
+				di.img.SetRGBA(x, y, nc)
+			}
+		}
 	}
 }
 
+func (di *DebugImage) DebugOutput(debugType string) {
+	writeImage("png", di.img, "./smartcrop_"+debugType+".png")
+}
+
 func writeImage(imgtype string, img image.Image, name string) error {
 	if err := os.MkdirAll(filepath.Dir(name), 0755); err != nil {
 		panic(err)
@@ -82,7 +164,9 @@ func writeImageToPng(img image.Image, name string) error {
 	return png.Encode(fso, img)
 }
 
-func drawDebugCrop(topCrop Crop, o *image.RGBA) {
+func (di *DebugImage) DrawDebugCrop(topCrop Crop) {
+	o := di.img
+
 	width := o.Bounds().Dx()
 	height := o.Bounds().Dy()
 

gocv/face.go

@@ -0,0 +1,125 @@
+// +build !ci
+
+package gocv
+
+import (
+	"fmt"
+	"image"
+	"os"
+
+	"gocv.io/x/gocv"
+
+	sclogger "github.com/muesli/smartcrop/logger"
+)
+
+type FaceDetector struct {
+	FaceDetectionHaarCascadeFilepath string
+	Logger                           *sclogger.Logger
+}
+
+func (d *FaceDetector) Name() string {
+	return "face"
+}
+
+func (d *FaceDetector) Bias() float64 {
+	return 0.9
+}
+
+func (d *FaceDetector) Weight() float64 {
+	return 1.8
+}
+
+func (d *FaceDetector) Detect(img *image.RGBA) ([][]uint8, error) {
+	res := make([][]uint8, img.Bounds().Dx())
+	for x := range res {
+		res[x] = make([]uint8, img.Bounds().Dy())
+	}
+
+	if img == nil {
+		return res, fmt.Errorf("img can't be nil")
+	}
+	if d.FaceDetectionHaarCascadeFilepath == "" {
+		return res, fmt.Errorf("FaceDetector's FaceDetectionHaarCascadeFilepath not specified")
+	}
+
+	_, err := os.Stat(d.FaceDetectionHaarCascadeFilepath)
+	if err != nil {
+		return res, err
+	}
+
+	classifier := gocv.NewCascadeClassifier()
+	defer classifier.Close()
+	if !classifier.Load(d.FaceDetectionHaarCascadeFilepath) {
+		return res, fmt.Errorf("FaceDetector failed loading cascade file")
+	}
+
+	// image.NRGBA-compatible params
+	cvMat, err := gocv.NewMatFromBytes(img.Rect.Dy(), img.Rect.Dx(), gocv.MatTypeCV8UC4, img.Pix)
+	defer cvMat.Close()
+	if err != nil {
+	   return res, err
+	}
+
+	faces := classifier.DetectMultiScale(cvMat)
+
+	if d.Logger.DebugMode == true {
+		d.Logger.Log.Printf("Number of faces detected: %d\n", len(faces))
+	}
+
+	for _, face := range faces {
+		// Upper left corner of detected face-rectangle
+		x := face.Min.X
+		y := face.Min.Y
+
+		width := face.Dx()
+		height := face.Dy()
+
+		if d.Logger.DebugMode == true {
+			d.Logger.Log.Printf("Face: x: %d y: %d w: %d h: %d\n", x, y, width, height)
+		}
+
+		drawAFilledCircle(res, x+(width/2), y+(height/2), width/2)
+	}
+	return res, nil
+}
+
+func drawAFilledCircle(pix [][]uint8, x0, y0, r int) {
+	x := r - 1
+	y := 0
+	dx := 1
+	dy := 1
+	err := dx - (r << 1)
+
+	for {
+		if x < y {
+			return
+		}
+
+		for i := -x; i <= x; i++ {
+			putPixel(pix, x0+i, y0+y)
+			putPixel(pix, x0+i, y0-y)
+			putPixel(pix, x0+y, y0+i)
+			putPixel(pix, x0-y, y0+i)
+		}
+
+		if err <= 0 {
+			y++
+			err += dy
+			dy += 2
+		} else {
+			x--
+			dx += 2
+			err += dx - (r << 1)
+		}
+	}
+}
+
+func putPixel(pix [][]uint8, x, y int) {
+	if x >= len(pix) {
+		return
+	}
+	if y >= len(pix[x]) {
+		return
+	}
+	pix[x][y] = uint8(255)
+}

logger/logger.go

@@ -0,0 +1,11 @@
+package logger
+
+import (
+	"log"
+)
+
+// Logger contains a logger.
+type Logger struct {
+	DebugMode bool
+	Log       *log.Logger
+}

smartcrop-rundebug/main.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"image"
+	_ "image/jpeg"
+	_ "image/png"
+	"log"
+	"os"
+
+	"github.com/muesli/smartcrop"
+	sclogger "github.com/muesli/smartcrop/logger"
+	"github.com/muesli/smartcrop/nfnt"
+	//	"github.com/muesli/smartcrop/gocv"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Println("Please give me an argument")
+		os.Exit(1)
+	}
+
+	f, _ := os.Open(os.Args[1])
+	img, _, _ := image.Decode(f)
+
+	l := sclogger.Logger{
+		DebugMode: true,
+		Log:       log.New(os.Stderr, "", 0),
+	}
+
+	analyzer := smartcrop.NewAnalyzerWithLogger(nfnt.NewDefaultResizer(), l)
+
+	/*
+		To replace skin detection with gocv-based face detection:
+
+		analyzer.SetDetectors([]smartcrop.Detector{
+			&gocv.FaceDetector{"./cascade.xml", &l},
+			&smartcrop.SaturationDetector{},
+		})
+	*/
+
+	topCrop, _ := analyzer.FindBestCrop(img, 300, 200)
+
+	// The crop will have the requested aspect ratio, but you need to copy/scale it yourself
+	fmt.Printf("Top crop: %+v\n", topCrop)
+}