Skip the temp-file/JPEG round trip when UseGray is set

AddImageToDataset, RecognizeSingle, and RecognizeMultiples used to
write a grayscale JPEG to a temp file just so go-face could immediately
decode that same JPEG back into pixels. With go-face v1.0.7's
RecognizeRaw (Kagami/go-face#69), the already-decoded, already-grayed
pixels go straight to goFace -- no temp file, no JPEG encode, no JPEG
decode. UseGray=false is unchanged: the file is still handed straight
to go-face, which still requires JPEG (see #45's boundary, already
documented/tested).

createTempGrayFile/tempFileName are gone, replaced by loadPixels
(decode + grayscale + pack into an RGB byte buffer) in image.go, and a
new detect() helper in recognizer.go shared by AddImageToDataset and
RecognizeMultiples (RecognizeSingle keeps its own branch, using
goFace's Single variants directly rather than detecting all faces and
discarding extras, matching its prior performance characteristics).

Verified: full test suite passes under -race, and it got noticeably
faster (~50s -> ~26s) with the temp-file I/O and JPEG round trip gone.
Also re-ran all three examples end-to-end -- faces.jpg/faces2.jpg came
out byte-identical (annotation draws over the original color image, not
the internal recognition path), landmarks.jpg shifted by ordinary
decoder-rounding differences only.

Author: Leandro

examples/landmarks.jpg

@@ -8,4 +8,4 @@ require (
 	golang.org/x/image v0.44.0
 )
 
-require github.com/leandroveronezi/go-face v1.0.5
+require github.com/leandroveronezi/go-face v1.0.7

go.mod

@@ -1,8 +1,6 @@
 package recognizer
 
 import (
-	"crypto/rand"
-	"encoding/hex"
 	goFace "github.com/leandroveronezi/go-face"
 	"github.com/fogleman/gg"
 	"github.com/golang/freetype/truetype"
@@ -11,7 +9,6 @@ import (
 	"image/color"
 	"image/jpeg"
 	"os"
-	"path/filepath"
 )
 
 /*
@@ -79,35 +76,37 @@ func (_this *Recognizer) GrayScale(imgSrc image.Image) image.Image {
 }
 
 /*
-createTempGrayFile create a temporary image in grayscale
+loadPixels loads Path, converts it to grayscale, and returns it as a
+tightly packed RGB pixel buffer (3 bytes per pixel, row-major) ready for
+goFace's Raw recognition methods -- no JPEG encoding/decoding involved.
 */
-func (_this *Recognizer) createTempGrayFile(Path, Id string) (string, error) {
-
-	name := _this.tempFileName(Id, ".jpeg")
+func (_this *Recognizer) loadPixels(Path string) (pixels []byte, width, height int, err error) {
 
 	img, err := _this.LoadImage(Path)
 
 	if err != nil {
-		return "", err
+		return nil, 0, 0, err
 	}
 
 	img = _this.GrayScale(img)
-	err = _this.SaveImage(name, img)
 
-	if err != nil {
-		os.Remove(name)
-		return "", err
-	}
+	bounds := img.Bounds()
+	width, height = bounds.Dx(), bounds.Dy()
+	pixels = make([]byte, width*height*3)
 
-	return name, nil
+	i := 0
+	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+		for x := bounds.Min.X; x < bounds.Max.X; x++ {
+			r, g, b, _ := img.At(x, y).RGBA()
+			pixels[i] = byte(r >> 8)
+			pixels[i+1] = byte(g >> 8)
+			pixels[i+2] = byte(b >> 8)
+			i += 3
+		}
+	}
 
-}
+	return pixels, width, height, nil
 
-// tempFileName generates a temporary filename
-func (_this *Recognizer) tempFileName(prefix, suffix string) string {
-	randBytes := make([]byte, 16)
-	rand.Read(randBytes)
-	return filepath.Join(os.TempDir(), prefix+hex.EncodeToString(randBytes)+suffix)
 }
 
 /*

image.go

@@ -111,38 +111,47 @@ func (_this *Recognizer) Close() {
 }
 
 /*
-AddImageToDataset add a sample image to the dataset.
-
-The new entry is appended to the underlying classifier immediately (via
-goFace.AppendSample), so it's classifiable right away -- no need to call
-SetSamples afterward. SetSamples is still required after LoadDataset or
-after mutating Dataset directly, since those don't go through this
-incremental path.
+detect runs face detection on Path, returning every face found. It
+prefers the raw-pixel path when UseGray is set -- decoding, grayscaling,
+and handing pixels straight to goFace, with no JPEG round trip involved
+-- and otherwise hands Path straight to go-face, which only understands
+JPEG.
 */
-func (_this *Recognizer) AddImageToDataset(Path string, Id string) error {
-
-	file := Path
-	var err error
+func (_this *Recognizer) detect(Path string) ([]goFace.Face, error) {
 
 	if _this.UseGray {
 
-		file, err = _this.createTempGrayFile(file, Id)
-
+		pixels, width, height, err := _this.loadPixels(Path)
 		if err != nil {
-			return err
+			return nil, err
 		}
 
-		defer os.Remove(file)
+		if _this.UseCNN {
+			return _this.rec.RecognizeRawCNN(pixels, width, height)
+		}
+		return _this.rec.RecognizeRaw(pixels, width, height)
 
 	}
 
-	var faces []goFace.Face
-
 	if _this.UseCNN {
-		faces, err = _this.rec.RecognizeFileCNN(file)
-	} else {
-		faces, err = _this.rec.RecognizeFile(file)
+		return _this.rec.RecognizeFileCNN(Path)
 	}
+	return _this.rec.RecognizeFile(Path)
+
+}
+
+/*
+AddImageToDataset add a sample image to the dataset.
+
+The new entry is appended to the underlying classifier immediately (via
+goFace.AppendSample), so it's classifiable right away -- no need to call
+SetSamples afterward. SetSamples is still required after LoadDataset or
+after mutating Dataset directly, since those don't go through this
+incremental path.
+*/
+func (_this *Recognizer) AddImageToDataset(Path string, Id string) error {
+
+	faces, err := _this.detect(Path)
 
 	if err != nil {
 		return err
@@ -199,31 +208,33 @@ func (_this *Recognizer) SetSamples() {
 
 /*
 RecognizeSingle returns face if it's the only face on the image or nil otherwise.
-Only JPEG format is currently supported.
 */
 func (_this *Recognizer) RecognizeSingle(Path string) (goFace.Face, error) {
 
-	file := Path
+	var idFace *goFace.Face
 	var err error
 
 	if _this.UseGray {
 
-		file, err = _this.createTempGrayFile(file, "64ab59ac42d69274f06eadb11348969e")
-
-		if err != nil {
-			return goFace.Face{}, err
+		pixels, width, height, lerr := _this.loadPixels(Path)
+		if lerr != nil {
+			return goFace.Face{}, lerr
 		}
 
-		defer os.Remove(file)
+		if _this.UseCNN {
+			idFace, err = _this.rec.RecognizeSingleRawCNN(pixels, width, height)
+		} else {
+			idFace, err = _this.rec.RecognizeSingleRaw(pixels, width, height)
+		}
 
-	}
+	} else {
 
-	var idFace *goFace.Face
+		if _this.UseCNN {
+			idFace, err = _this.rec.RecognizeSingleFileCNN(Path)
+		} else {
+			idFace, err = _this.rec.RecognizeSingleFile(Path)
+		}
 
-	if _this.UseCNN {
-		idFace, err = _this.rec.RecognizeSingleFileCNN(file)
-	} else {
-		idFace, err = _this.rec.RecognizeSingleFile(file)
 	}
 
 	if err != nil {
@@ -242,32 +253,10 @@ func (_this *Recognizer) RecognizeSingle(Path string) (goFace.Face, error) {
 RecognizeMultiples returns all faces found on the provided image, sorted from
 left to right. Empty list is returned if there are no faces, error is
 returned if there was some error while decoding/processing image.
-Only JPEG format is currently supported.
 */
 func (_this *Recognizer) RecognizeMultiples(Path string) ([]goFace.Face, error) {
 
-	file := Path
-	var err error
-
-	if _this.UseGray {
-
-		file, err = _this.createTempGrayFile(file, "64ab59ac42d69274f06eadb11348969e")
-
-		if err != nil {
-			return nil, err
-		}
-
-		defer os.Remove(file)
-
-	}
-
-	var idFaces []goFace.Face
-
-	if _this.UseCNN {
-		idFaces, err = _this.rec.RecognizeFileCNN(file)
-	} else {
-		idFaces, err = _this.rec.RecognizeFile(file)
-	}
+	idFaces, err := _this.detect(Path)
 
 	if err != nil {
 		return nil, fmt.Errorf("Can't recognize: %v", err)