finished image_process filter

helper/template_filters.go

@@ -1,13 +1,19 @@
 package helper
 
 import (
+	"crypto/md5"
 	"errors"
 	"fmt"
+	"image"
 	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
 	"path"
 	"strconv"
 	"strings"
 
+	"gitbase.de/apairon/mark2web/config"
 	"github.com/ddliu/motto"
 	"github.com/disintegration/imaging"
 	"github.com/flosch/pongo2"
@@ -22,7 +28,7 @@ func init() {
 	}
 
 	newFilters := map[string]pongo2.FilterFunction{
-		"image_resize":  ImageResizeFilter,
+		"image_process": ImageProcessFilter,
 		"relative_path": RelativePathFilter,
 	}
 	for name, fn := range newFilters {
@@ -44,17 +50,15 @@ func MarkdownFilter(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pong
 		nil
 }
 
-type imageParams struct {
-	width    int
-	height   int
-	filename string
-}
-
-func parseImageParams(str string) (*imageParams, error) {
+func parseImageParams(str string) (*config.ImagingConfig, error) {
+	p := config.ImagingConfig{}
 	if str == "" {
-		return nil, errors.New("missing image parameters")
+		config.Merge(&p, currentPathConfig.Imaging)
+		// Filename and Format are only valid for current image
+		p.Filename = ""
+		p.Format = ""
+		return &p, nil
 	}
-	p := imageParams{}
 	for _, s := range strings.Split(str, ",") {
 		e := strings.Split(s, "=")
 		if len(e) < 2 {
@@ -63,11 +67,20 @@ func parseImageParams(str string) (*imageParams, error) {
 		var err error
 		switch e[0] {
 		case "w":
-			p.width, err = strconv.Atoi(e[1])
+			p.Width, err = strconv.Atoi(e[1])
 		case "h":
-			p.height, err = strconv.Atoi(e[1])
+			p.Height, err = strconv.Atoi(e[1])
 		case "f":
-			p.filename = e[1]
+			p.Filename = e[1]
+		case "p":
+			p.Process = e[1]
+		case "a":
+			p.Anchor = e[1]
+		case "q":
+			p.Quality, err = strconv.Atoi(e[1])
+			if p.Quality < 0 || p.Quality > 100 {
+				err = errors.New("q= must be between 1 and 100")
+			}
 		default:
 			return nil, fmt.Errorf("invalid image parameter: %s", s)
 		}
@@ -78,9 +91,23 @@ func parseImageParams(str string) (*imageParams, error) {
 	return &p, nil
 }
 
-// ImageResizeFilter read the image url and resize parameters and saves the resized image
+func getImageFromURL(url string) (image.Image, string, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, "", fmt.Errorf("could not get url '%s': %s", url, err)
+	}
+
+	img, format, err := image.Decode(resp.Body)
+	if err != nil {
+		return nil, "", fmt.Errorf("could read body from url '%s': %s", url, err)
+	}
+
+	return img, format, nil
+}
+
+// ImageProcessFilter read the image url and process parameters and saves the resized/processed image
 // param: w=WITDH,h=HEIGHT
-func ImageResizeFilter(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+func ImageProcessFilter(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
 	imgSource := in.String()
 	p, err := parseImageParams(param.String())
 	if err != nil {
@@ -89,32 +116,124 @@ func ImageResizeFilter(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *p
 			OrigError: err,
 		}
 	}
-
-	imgSource = ResolveInputPath(imgSource)
-	if p.filename == "" {
-		p.filename = fmt.Sprintf("%dx%d_%s", p.width, p.height, path.Base(imgSource))
+	if p == nil {
+		return nil, &pongo2.Error{
+			Sender:    "filter:image_resize",
+			OrigError: errors.New("no imaging config defined"),
+		}
 	}
-	imgTarget := ResolveOutputPath(p.filename)
-	Log.Noticef("resizing image from %s to %s", imgSource, imgTarget)
 
-	img, err := imaging.Open(imgSource, imaging.AutoOrientation(true))
+	var img image.Image
+	if p.Process == "" {
+		p.Process = "resize"
+	}
+	filePrefix := fmt.Sprintf(
+		"%s_%dx%d_q%03d",
+		p.Process,
+		p.Width,
+		p.Height,
+		p.Quality,
+	)
+	if strings.HasPrefix(imgSource, "http://") || strings.HasPrefix(imgSource, "https://") {
+		// remote file
+		img, p.Format, err = getImageFromURL(imgSource)
+		// build filename
+		if p.Filename == "" {
+			var fBase string
+			if u, _ := url.Parse(imgSource); u != nil {
+				fBase = strings.Split(path.Base(u.Path), ".")[0]
+			}
+
+			p.Filename = fmt.Sprintf(
+				"%s_%x_%s.%s",
+				filePrefix,
+				md5.Sum([]byte(imgSource)),
+				fBase,
+				p.Format,
+			)
+		}
+	} else {
+		// local file
+		imgSource = ResolveInputPath(imgSource)
+		img, err = imaging.Open(imgSource, imaging.AutoOrientation(true))
+		if p.Filename == "" {
+			p.Filename = fmt.Sprintf(
+				"%s_%s",
+				filePrefix,
+				path.Base(imgSource),
+			)
+		}
+	}
 	if err != nil {
 		return nil, &pongo2.Error{
 			Sender:    "filter:image_resize",
 			OrigError: fmt.Errorf("could not open image '%s': %s", imgSource, err),
 		}
 	}
-	img = imaging.Resize(img, p.width, p.height, imaging.Lanczos)
 
-	err = imaging.Save(img, imgTarget)
-	if err != nil {
-		return nil, &pongo2.Error{
-			Sender:    "filter:image_resize",
-			OrigError: fmt.Errorf("could save image '%s': %s", imgTarget, err),
+	imgTarget := ResolveOutputPath(p.Filename)
+
+	if f, err := os.Stat(imgTarget); err == nil && !f.IsDir() {
+		Log.Noticef("skipped processing image from %s to %s, file already exists", imgSource, imgTarget)
+	} else {
+		Log.Noticef("processing image from %s to %s", imgSource, imgTarget)
+
+		switch p.Process {
+		case "resize":
+			img = imaging.Resize(img, p.Width, p.Height, imaging.Lanczos)
+		case "fit":
+			img = imaging.Fit(img, p.Width, p.Height, imaging.Lanczos)
+		case "fill":
+			var anchor imaging.Anchor
+			switch strings.ToLower(p.Anchor) {
+			case "":
+				fallthrough
+			case "center":
+				anchor = imaging.Center
+			case "topleft":
+				anchor = imaging.TopLeft
+			case "top":
+				anchor = imaging.Top
+			case "topright":
+				anchor = imaging.TopRight
+			case "left":
+				anchor = imaging.Left
+			case "right":
+				anchor = imaging.Right
+			case "bottomleft":
+				anchor = imaging.BottomLeft
+			case "bottom":
+				anchor = imaging.Bottom
+			case "bottomright":
+				anchor = imaging.BottomRight
+			default:
+				return nil, &pongo2.Error{
+					Sender:    "filter:image_resize",
+					OrigError: fmt.Errorf("unknown anchor a=%s definition", p.Anchor),
+				}
+			}
+			img = imaging.Fill(img, p.Width, p.Height, anchor, imaging.Lanczos)
+		default:
+			return nil, &pongo2.Error{
+				Sender:    "filter:image_resize",
+				OrigError: fmt.Errorf("invalid p parameter '%s'", p.Process),
+			}
+		}
+
+		var encodeOptions = make([]imaging.EncodeOption, 0)
+		if p.Quality > 0 {
+			encodeOptions = append(encodeOptions, imaging.JPEGQuality(p.Quality))
+		}
+
+		err = imaging.Save(img, imgTarget, encodeOptions...)
+		if err != nil {
+			return nil, &pongo2.Error{
+				Sender:    "filter:image_resize",
+				OrigError: fmt.Errorf("could save image '%s': %s", imgTarget, err),
+			}
 		}
 	}
-
-	return pongo2.AsValue(ResolveNavPath(p.filename)), nil
+	return pongo2.AsValue(ResolveNavPath(p.Filename)), nil
 }
 
 // RelativePathFilter returns the relative path to navpoint based on current nav