AWS Lambda が HTTPS エンドポイントをサポートしたので試してみた。

package main

import (
	"bytes"
	"context"
	"embed"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"image"
	"image/jpeg"
	_ "image/png"
	"io/ioutil"
	"log"
	"net/http"
	"strings"

	"github.com/aws/aws-lambda-go/lambda"
	pigo "github.com/esimov/pigo/core"
	"github.com/nfnt/resize"
	"golang.org/x/image/draw"
)

var (
	maskImg    image.Image
	classifier *pigo.Pigo
)

//go:embed data
var fs embed.FS

func init() {
	f, err := fs.Open("data/mask.png")
	if err != nil {
		log.Fatal("cannot open mask.png:", err)
	}
	defer f.Close()

	maskImg, _, err = image.Decode(f)
	if err != nil {
		log.Fatal("cannot decode mask.png:", err)
	}

	f, err = fs.Open("data/facefinder")
	if err != nil {
		log.Fatal("cannot open facefinder:", err)
	}
	defer f.Close()

	b, err := ioutil.ReadAll(f)
	if err != nil {
		log.Fatal("cannot read facefinder:", err)
	}

	pigo := pigo.NewPigo()
	classifier, err = pigo.Unpack(b)
	if err != nil {
		log.Fatal("cannot unpack facefinder:", err)
	}
}

type Payload struct {
	Body            string `json:"body"`
	IsBase64Encoded bool   `json:"isBase64Encoded"`
}

type Request struct {
	ImgURL string `json:"img_url"`
}

func main() {
	lambda.Start(func(ctx context.Context, payload Payload) (string, error) {
		var req Request
		if payload.IsBase64Encoded {
			b, err := base64.StdEncoding.DecodeString(payload.Body)
			if err != nil {
				return "", fmt.Errorf("cannot decode payload: %v: %v", err, payload.Body)
			}
			err = json.NewDecoder(bytes.NewReader(b)).Decode(&req)
			if err != nil {
				return "", fmt.Errorf("cannot decode payload: %v: %v", err, payload.Body)
			}
		} else {
			err := json.NewDecoder(strings.NewReader(payload.Body)).Decode(&req)
			if err != nil {
				return "", fmt.Errorf("cannot decode payload: %v: %v", err, payload.Body)
			}
		}

		resp, err := http.Get(req.ImgURL)
		if err != nil {
			return "", fmt.Errorf("cannot get image: %v: %v", err, req.ImgURL)
		}
		defer resp.Body.Close()

		img, _, err := image.Decode(resp.Body)
		if err != nil {
			return "", fmt.Errorf("cannot decode input image: %v: %v", err, req.ImgURL)
		}
		bounds := img.Bounds().Max
		param := pigo.CascadeParams{
			MinSize:     20,
			MaxSize:     2000,
			ShiftFactor: 0.1,
			ScaleFactor: 1.1,
			ImageParams: pigo.ImageParams{
				Pixels: pigo.RgbToGrayscale(pigo.ImgToNRGBA(img)),
				Rows:   bounds.Y,
				Cols:   bounds.X,
				Dim:    bounds.X,
			},
		}
		faces := classifier.RunCascade(param, 0)
		faces = classifier.ClusterDetections(faces, 0.18)

		canvas := image.NewRGBA(img.Bounds())
		draw.Draw(canvas, img.Bounds(), img, image.Point{0, 0}, draw.Over)
		for _, face := range faces {
			pt := image.Point{face.Col - face.Scale/2, face.Row - face.Scale/2}
			fimg := resize.Resize(uint(face.Scale), uint(face.Scale), maskImg, resize.NearestNeighbor)
			log.Println(pt.X, pt.Y, face.Scale)
			draw.Copy(canvas, pt, fimg, fimg.Bounds(), draw.Over, nil)
		}
		var buf bytes.Buffer
		err = jpeg.Encode(&buf, canvas, &jpeg.Options{Quality: 100})
		if err != nil {
			return "", fmt.Errorf("cannot encode output image: %v", err)
		}
		return base64.StdEncoding.EncodeToString(buf.Bytes()), nil
	})
}

type Payload struct {
	Body            string `json:"body"`
	IsBase64Encoded bool   `json:"isBase64Encoded"`
}

type Request struct {
	ImgURL string `json:"img_url"`
}

var req Request
if payload.IsBase64Encoded {
	b, err := base64.StdEncoding.DecodeString(payload.Body)
	if err != nil {
		return "", fmt.Errorf("cannot decode payload: %v: %v", err, payload.Body)
	}
	err = json.NewDecoder(bytes.NewReader(b)).Decode(&req)
	if err != nil {
		return "", fmt.Errorf("cannot decode payload: %v: %v", err, payload.Body)
	}
} else {
	err := json.NewDecoder(strings.NewReader(payload.Body)).Decode(&req)
	if err != nil {
		return "", fmt.Errorf("cannot decode payload: %v: %v", err, payload.Body)
	}
}