v0.0.451 wpdf image processing

imageext/enums.go

@@ -0,0 +1,3 @@
+package imageext
+
+//go:generate go run ../_gen/enum-generate.go -- enums_gen.go

imageext/enums_gen.go

@@ -0,0 +1,300 @@
+// Code generated by enum-generate.go DO NOT EDIT.
+
+package imageext
+
+import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import "gogs.mikescher.com/BlackForestBytes/goext/enums"
+
+const ChecksumEnumGenerator = "1da5383c33ee442fd0b899369053f66bdc85bed2dbf906949d3edfeedfe13340" // GoExtVersion: 0.0.449
+
+// ================================ ImageFit ================================
+//
+// File:       image.go
+// StringEnum: true
+// DescrEnum:  false
+// DataEnum:   false
+//
+
+var __ImageFitValues = []ImageFit{
+	ImageFitStretch,
+	ImageFitCover,
+	ImageFitContainCenter,
+	ImageFitContainTopLeft,
+	ImageFitContainTopRight,
+	ImageFitContainBottomLeft,
+	ImageFitContainBottomRight,
+}
+
+var __ImageFitVarnames = map[ImageFit]string{
+	ImageFitStretch:            "ImageFitStretch",
+	ImageFitCover:              "ImageFitCover",
+	ImageFitContainCenter:      "ImageFitContainCenter",
+	ImageFitContainTopLeft:     "ImageFitContainTopLeft",
+	ImageFitContainTopRight:    "ImageFitContainTopRight",
+	ImageFitContainBottomLeft:  "ImageFitContainBottomLeft",
+	ImageFitContainBottomRight: "ImageFitContainBottomRight",
+}
+
+func (e ImageFit) Valid() bool {
+	return langext.InArray(e, __ImageFitValues)
+}
+
+func (e ImageFit) Values() []ImageFit {
+	return __ImageFitValues
+}
+
+func (e ImageFit) ValuesAny() []any {
+	return langext.ArrCastToAny(__ImageFitValues)
+}
+
+func (e ImageFit) ValuesMeta() []enums.EnumMetaValue {
+	return ImageFitValuesMeta()
+}
+
+func (e ImageFit) String() string {
+	return string(e)
+}
+
+func (e ImageFit) VarName() string {
+	if d, ok := __ImageFitVarnames[e]; ok {
+		return d
+	}
+	return ""
+}
+
+func (e ImageFit) TypeName() string {
+	return "ImageFit"
+}
+
+func (e ImageFit) PackageName() string {
+	return "media"
+}
+
+func (e ImageFit) Meta() enums.EnumMetaValue {
+	return enums.EnumMetaValue{VarName: e.VarName(), Value: e, Description: nil}
+}
+
+func ParseImageFit(vv string) (ImageFit, bool) {
+	for _, ev := range __ImageFitValues {
+		if string(ev) == vv {
+			return ev, true
+		}
+	}
+	return "", false
+}
+
+func ImageFitValues() []ImageFit {
+	return __ImageFitValues
+}
+
+func ImageFitValuesMeta() []enums.EnumMetaValue {
+	return []enums.EnumMetaValue{
+		ImageFitStretch.Meta(),
+		ImageFitCover.Meta(),
+		ImageFitContainCenter.Meta(),
+		ImageFitContainTopLeft.Meta(),
+		ImageFitContainTopRight.Meta(),
+		ImageFitContainBottomLeft.Meta(),
+		ImageFitContainBottomRight.Meta(),
+	}
+}
+
+// ================================ ImageCompresson ================================
+//
+// File:       image.go
+// StringEnum: true
+// DescrEnum:  false
+// DataEnum:   false
+//
+
+var __ImageCompressonValues = []ImageCompresson{
+	CompressionPNGNone,
+	CompressionPNGSpeed,
+	CompressionPNGBest,
+	CompressionJPEG100,
+	CompressionJPEG90,
+	CompressionJPEG80,
+	CompressionJPEG70,
+	CompressionJPEG60,
+	CompressionJPEG50,
+	CompressionJPEG25,
+	CompressionJPEG10,
+	CompressionJPEG1,
+}
+
+var __ImageCompressonVarnames = map[ImageCompresson]string{
+	CompressionPNGNone:  "CompressionPNGNone",
+	CompressionPNGSpeed: "CompressionPNGSpeed",
+	CompressionPNGBest:  "CompressionPNGBest",
+	CompressionJPEG100:  "CompressionJPEG100",
+	CompressionJPEG90:   "CompressionJPEG90",
+	CompressionJPEG80:   "CompressionJPEG80",
+	CompressionJPEG70:   "CompressionJPEG70",
+	CompressionJPEG60:   "CompressionJPEG60",
+	CompressionJPEG50:   "CompressionJPEG50",
+	CompressionJPEG25:   "CompressionJPEG25",
+	CompressionJPEG10:   "CompressionJPEG10",
+	CompressionJPEG1:    "CompressionJPEG1",
+}
+
+func (e ImageCompresson) Valid() bool {
+	return langext.InArray(e, __ImageCompressonValues)
+}
+
+func (e ImageCompresson) Values() []ImageCompresson {
+	return __ImageCompressonValues
+}
+
+func (e ImageCompresson) ValuesAny() []any {
+	return langext.ArrCastToAny(__ImageCompressonValues)
+}
+
+func (e ImageCompresson) ValuesMeta() []enums.EnumMetaValue {
+	return ImageCompressonValuesMeta()
+}
+
+func (e ImageCompresson) String() string {
+	return string(e)
+}
+
+func (e ImageCompresson) VarName() string {
+	if d, ok := __ImageCompressonVarnames[e]; ok {
+		return d
+	}
+	return ""
+}
+
+func (e ImageCompresson) TypeName() string {
+	return "ImageCompresson"
+}
+
+func (e ImageCompresson) PackageName() string {
+	return "media"
+}
+
+func (e ImageCompresson) Meta() enums.EnumMetaValue {
+	return enums.EnumMetaValue{VarName: e.VarName(), Value: e, Description: nil}
+}
+
+func ParseImageCompresson(vv string) (ImageCompresson, bool) {
+	for _, ev := range __ImageCompressonValues {
+		if string(ev) == vv {
+			return ev, true
+		}
+	}
+	return "", false
+}
+
+func ImageCompressonValues() []ImageCompresson {
+	return __ImageCompressonValues
+}
+
+func ImageCompressonValuesMeta() []enums.EnumMetaValue {
+	return []enums.EnumMetaValue{
+		CompressionPNGNone.Meta(),
+		CompressionPNGSpeed.Meta(),
+		CompressionPNGBest.Meta(),
+		CompressionJPEG100.Meta(),
+		CompressionJPEG90.Meta(),
+		CompressionJPEG80.Meta(),
+		CompressionJPEG70.Meta(),
+		CompressionJPEG60.Meta(),
+		CompressionJPEG50.Meta(),
+		CompressionJPEG25.Meta(),
+		CompressionJPEG10.Meta(),
+		CompressionJPEG1.Meta(),
+	}
+}
+
+// ================================ MimeCategory ================================
+//
+// File:       mime.go
+// StringEnum: true
+// DescrEnum:  false
+// DataEnum:   false
+//
+
+var __MimeCategoryValues = []MimeCategory{
+	CatDocument,
+	CatImage,
+	CatVideo,
+	CatContainer,
+}
+
+var __MimeCategoryVarnames = map[MimeCategory]string{
+	CatDocument:  "CatDocument",
+	CatImage:     "CatImage",
+	CatVideo:     "CatVideo",
+	CatContainer: "CatContainer",
+}
+
+func (e MimeCategory) Valid() bool {
+	return langext.InArray(e, __MimeCategoryValues)
+}
+
+func (e MimeCategory) Values() []MimeCategory {
+	return __MimeCategoryValues
+}
+
+func (e MimeCategory) ValuesAny() []any {
+	return langext.ArrCastToAny(__MimeCategoryValues)
+}
+
+func (e MimeCategory) ValuesMeta() []enums.EnumMetaValue {
+	return MimeCategoryValuesMeta()
+}
+
+func (e MimeCategory) String() string {
+	return string(e)
+}
+
+func (e MimeCategory) VarName() string {
+	if d, ok := __MimeCategoryVarnames[e]; ok {
+		return d
+	}
+	return ""
+}
+
+func (e MimeCategory) TypeName() string {
+	return "MimeCategory"
+}
+
+func (e MimeCategory) PackageName() string {
+	return "media"
+}
+
+func (e MimeCategory) Meta() enums.EnumMetaValue {
+	return enums.EnumMetaValue{VarName: e.VarName(), Value: e, Description: nil}
+}
+
+func ParseMimeCategory(vv string) (MimeCategory, bool) {
+	for _, ev := range __MimeCategoryValues {
+		if string(ev) == vv {
+			return ev, true
+		}
+	}
+	return "", false
+}
+
+func MimeCategoryValues() []MimeCategory {
+	return __MimeCategoryValues
+}
+
+func MimeCategoryValuesMeta() []enums.EnumMetaValue {
+	return []enums.EnumMetaValue{
+		CatDocument.Meta(),
+		CatImage.Meta(),
+		CatVideo.Meta(),
+		CatContainer.Meta(),
+	}
+}
+
+// ================================ ================= ================================
+
+func AllPackageEnums() []enums.Enum {
+	return []enums.Enum{
+		ImageFitStretch,    // ImageFit
+		CompressionPNGNone, // ImageCompresson
+		CatDocument,        // MimeCategory
+	}
+}

imageext/image.go

@@ -0,0 +1,317 @@
+package imageext
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/disintegration/imaging"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"gogs.mikescher.com/BlackForestBytes/goext/mathext"
+	"image"
+	"image/color"
+	"image/draw"
+	"image/jpeg"
+	"image/png"
+	"io"
+	"math"
+)
+
+type ImageFit string //@enum:type
+
+const (
+	ImageFitStretch            ImageFit = "STRETCH"
+	ImageFitCover              ImageFit = "COVER"
+	ImageFitContainCenter      ImageFit = "CONTAIN_CENTER"
+	ImageFitContainTopLeft     ImageFit = "CONTAIN_TOPLEFT"
+	ImageFitContainTopRight    ImageFit = "CONTAIN_TOPRIGHT"
+	ImageFitContainBottomLeft  ImageFit = "CONTAIN_BOTTOMLEFT"
+	ImageFitContainBottomRight ImageFit = "CONTAIN_BOTTOMRIGHT"
+)
+
+type ImageCrop struct { // all crop values are percentages!
+
+	CropX      float64 `bson:"cropX"      json:"cropX"`
+	CropY      float64 `bson:"cropY"      json:"cropY"`
+	CropWidth  float64 `bson:"cropWidth"  json:"cropWidth"`
+	CropHeight float64 `bson:"cropHeight" json:"cropHeight"`
+}
+
+type ImageCompresson string //@enum:type
+
+const (
+	CompressionPNGNone  ImageCompresson = "PNG_NONE"
+	CompressionPNGSpeed ImageCompresson = "PNG_SPEED"
+	CompressionPNGBest  ImageCompresson = "PNG_BEST"
+	CompressionJPEG100  ImageCompresson = "JPEG_100"
+	CompressionJPEG90   ImageCompresson = "JPEG_090"
+	CompressionJPEG80   ImageCompresson = "JPEG_080"
+	CompressionJPEG70   ImageCompresson = "JPEG_070"
+	CompressionJPEG60   ImageCompresson = "JPEG_060"
+	CompressionJPEG50   ImageCompresson = "JPEG_050"
+	CompressionJPEG25   ImageCompresson = "JPEG_025"
+	CompressionJPEG10   ImageCompresson = "JPEG_010"
+	CompressionJPEG1    ImageCompresson = "JPEG_001"
+)
+
+func CropImage(img image.Image, px float64, py float64, pw float64, ph float64) (image.Image, error) {
+
+	type subImager interface {
+		SubImage(r image.Rectangle) image.Image
+	}
+
+	x := int(float64(img.Bounds().Dx()) * px)
+	y := int(float64(img.Bounds().Dy()) * py)
+	w := int(float64(img.Bounds().Dx()) * pw)
+	h := int(float64(img.Bounds().Dy()) * ph)
+
+	if simg, ok := img.(subImager); ok {
+
+		return simg.SubImage(image.Rect(x, y, x+w, y+h)), nil
+
+	} else {
+
+		bfr1 := bytes.Buffer{}
+		err := png.Encode(&bfr1, img)
+		if err != nil {
+			return nil, exerr.Wrap(err, "").Build()
+		}
+		imgPNG, err := png.Decode(&bfr1)
+		if err != nil {
+			return nil, exerr.Wrap(err, "").Build()
+		}
+
+		return imgPNG.(subImager).SubImage(image.Rect(x, y, w+w, y+h)), nil
+	}
+}
+
+func EncodeImage(img image.Image, compression ImageCompresson) (bytes.Buffer, string, error) {
+	var err error
+
+	bfr := bytes.Buffer{}
+
+	switch compression {
+	case CompressionPNGNone:
+		enc := &png.Encoder{CompressionLevel: png.NoCompression}
+		err = enc.Encode(&bfr, img)
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/png", nil
+	case CompressionPNGSpeed:
+		enc := &png.Encoder{CompressionLevel: png.BestSpeed}
+		err = enc.Encode(&bfr, img)
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/png", nil
+	case CompressionPNGBest:
+		enc := &png.Encoder{CompressionLevel: png.BestCompression}
+		err = enc.Encode(&bfr, img)
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/png", nil
+	case CompressionJPEG100:
+		err = jpeg.Encode(&bfr, img, &jpeg.Options{Quality: 100})
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/jpeg", nil
+	case CompressionJPEG90:
+		err = jpeg.Encode(&bfr, img, &jpeg.Options{Quality: 90})
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/jpeg", nil
+	case CompressionJPEG80:
+		err = jpeg.Encode(&bfr, img, &jpeg.Options{Quality: 80})
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/jpeg", nil
+	case CompressionJPEG70:
+		err = jpeg.Encode(&bfr, img, &jpeg.Options{Quality: 70})
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/jpeg", nil
+	case CompressionJPEG60:
+		err = jpeg.Encode(&bfr, img, &jpeg.Options{Quality: 60})
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/jpeg", nil
+	case CompressionJPEG50:
+		err = jpeg.Encode(&bfr, img, &jpeg.Options{Quality: 50})
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/jpeg", nil
+	case CompressionJPEG25:
+		err = jpeg.Encode(&bfr, img, &jpeg.Options{Quality: 25})
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/jpeg", nil
+	case CompressionJPEG10:
+		err = jpeg.Encode(&bfr, img, &jpeg.Options{Quality: 10})
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/jpeg", nil
+	case CompressionJPEG1:
+		err = jpeg.Encode(&bfr, img, &jpeg.Options{Quality: 1})
+		if err != nil {
+			return bytes.Buffer{}, "", exerr.Wrap(err, "").Build()
+		}
+		return bfr, "image/jpeg", nil
+	default:
+		return bytes.Buffer{}, "", exerr.New(exerr.TypeInternal, "unknown compression method: "+compression.String()).Build()
+	}
+}
+
+func ObjectFitImage(img image.Image, bbw float64, bbh float64, fit ImageFit, fillColor color.Color) (image.Image, error) {
+
+	iw := img.Bounds().Size().X
+	ih := img.Bounds().Size().Y
+
+	// [iw, ih]   is the size of the image
+	// [bbw, bbh] is the target bounding box,
+	//             - it specifies the target ratio
+	//             - and the maximal target resolution
+
+	facW := float64(iw) / bbw
+	facH := float64(ih) / bbh
+
+	// facW is the ratio between iw and bbw
+	//  - it is the factor by which the bounding box must be multiplied to reach the image size (in the x-axis)
+	//
+	// (same is true for facH, but for the height and y-axis)
+
+	if fit == ImageFitCover {
+
+		// image-fit:cover completely fills the target-bounding-box, it potentially cuts parts of the image away
+
+		// we use the smaller (!) value of facW and facH, because we want to have the smallest possible destination rect (due to file size)
+		// and because the image is made to completely fill the bounding-box, the smaller factor (= teh dimension the image is stretched more) is relevant
+
+		// but we cap `fac` at 1 (can be larger than 1)
+		// a value >1 would mean the final image resolution is biger than the bounding box, which we do not want.
+
+		// if the initial image (iw, ih) is already bigger than the bounding box (bbw, bbh), facW and facH are always >1 and fac will be 1
+		// which means we will simply use the bounding box as destination rect (and scale the image down)
+
+		fac := mathext.Clamp(mathext.Min(facW, facH), 0.0, 1.0)
+
+		// we scale the bounding box by fac (both dimension the same amount, to keep the bounding-box ratio)
+
+		w := int(math.Round(bbw * fac))
+		h := int(math.Round(bbh * fac))
+
+		img = imaging.Fill(img, w, h, imaging.Center, imaging.Lanczos)
+
+		newImg := image.NewRGBA(image.Rect(0, 0, w, h))
+
+		draw.Draw(newImg, newImg.Bounds(), &image.Uniform{C: fillColor}, image.Pt(0, 0), draw.Src)
+		draw.Draw(newImg, newImg.Bounds(), img, image.Pt(0, 0), draw.Over)
+
+		return newImg, nil
+	}
+
+	if fit == ImageFitContainCenter || fit == ImageFitContainTopLeft || fit == ImageFitContainTopRight || fit == ImageFitContainBottomLeft || fit == ImageFitContainBottomRight {
+
+		// image-fit:cover fills the target-bounding-box with the image, there is potentially empty-space, it potentially cuts parts of the image away
+
+		// we use the bigger (!) value of facW and facH,
+		// because the image is made to fit the bounding-box, the bigger factor (= the dimension the image is stretched less) is relevant
+
+		// but we cap `fac` at 1 (can be larger than 1)
+		// a value >1 would mean the final image resolution is biger than the bounding box, which we do not want.
+
+		// if the initial image (iw, ih) is already bigger than the bounding box (bbw, bbh), facW and facH are always >1 and fac will be 1
+		// which means we will simply use the bounding box as destination rect (and scale the image down)
+
+		facOut := mathext.Clamp(mathext.Max(facW, facH), 0.0, 1.0)
+
+		// we scale the bounding box by fac (both dimension the same amount, to keep the bounding-box ratio)
+
+		ow := int(math.Round(bbw * facOut))
+		oh := int(math.Round(bbh * facOut))
+
+		facScale := mathext.Min(float64(ow)/float64(iw), float64(oh)/float64(ih))
+
+		dw := int(math.Round(float64(iw) * facScale))
+		dh := int(math.Round(float64(ih) * facScale))
+
+		img = imaging.Resize(img, dw, dh, imaging.Lanczos)
+
+		var destBounds image.Rectangle
+		if fit == ImageFitContainCenter {
+			destBounds = image.Rect((ow-dw)/2, (oh-dh)/2, (ow-dw)/2+dw, (oh-dh)/2+dh)
+		} else if fit == ImageFitContainTopLeft {
+			destBounds = image.Rect(0, 0, iw, dh)
+		} else if fit == ImageFitContainTopRight {
+			destBounds = image.Rect(ow-iw, 0, ow, dh)
+		} else if fit == ImageFitContainBottomLeft {
+			destBounds = image.Rect(0, oh-dh, iw, oh)
+		} else if fit == ImageFitContainBottomRight {
+			destBounds = image.Rect(ow-dw, oh-dh, ow, oh)
+		}
+
+		newImg := image.NewRGBA(image.Rect(0, 0, ow, oh))
+
+		draw.Draw(newImg, newImg.Bounds(), &image.Uniform{C: fillColor}, image.Pt(0, 0), draw.Src)
+		draw.Draw(newImg, destBounds, img, image.Pt(0, 0), draw.Over)
+
+		return newImg, nil
+	}
+
+	if fit == ImageFitStretch {
+
+		// image-fit:stretch simply stretches the image to the bounding box
+
+		// we use the bigger value of [facW;facH], to (potentially) scale the bounding box down before applying it
+		// theoretically we could directly use [bbw, bbh] in the call to imaging.Resize,
+		// but if the image is (a lot) smaller than the bouding box it is useful to scale it down to reduce final pdf filesize
+
+		// we also cap fac at 1, because we never want the final rect to be bigger than the inputted bounding box (see comments at start of method)
+
+		fac := mathext.Clamp(mathext.Max(facW, facH), 0.0, 1.0)
+
+		// we scale the bounding box by fac (both dimension the same amount, to keep the bounding-box ratio)
+
+		w := int(math.Round(bbw * fac))
+		h := int(math.Round(bbh * fac))
+
+		img = imaging.Resize(img, w, h, imaging.Lanczos)
+
+		newImg := image.NewRGBA(image.Rect(0, 0, w, h))
+
+		draw.Draw(newImg, newImg.Bounds(), &image.Uniform{C: fillColor}, image.Pt(0, 0), draw.Src)
+		draw.Draw(newImg, newImg.Bounds(), img, image.Pt(0, 0), draw.Over)
+
+		return newImg, nil
+	}
+
+	return nil, exerr.New(exerr.TypeInternal, fmt.Sprintf("unknown image-fit: '%s'", fit)).Build()
+}
+
+func VerifyAndDecodeImage(data io.Reader, mime string) (image.Image, error) {
+
+	if mime == "image/jpeg" {
+		img, err := jpeg.Decode(data)
+		if err != nil {
+			return nil, exerr.Wrap(err, "failed to decode blob as jpeg").WithType(exerr.TypeInvalidImage).Build()
+		}
+		return img, nil
+	}
+
+	if mime == "image/png" {
+		img, err := png.Decode(data)
+		if err != nil {
+			return nil, exerr.Wrap(err, "failed to decode blob as png").WithType(exerr.TypeInvalidImage).Build()
+		}
+		return img, nil
+	}
+
+	return nil, exerr.New(exerr.TypeInvalidMimeType, fmt.Sprintf("unknown/invalid image mimetype: '%s'", mime)).Build()
+}