104 lines
2.8 KiB
Go
104 lines
2.8 KiB
Go
package infra
|
|
|
|
import (
|
|
"fmt"
|
|
"image"
|
|
"image/jpeg"
|
|
"image/png"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
// ThumbnailGenerate lee una imagen JPEG o PNG desde srcPath, la redimensiona
|
|
// manteniendo aspect ratio para que quepa dentro de (maxWidth, maxHeight) y guarda
|
|
// el resultado en dstPath con el formato inferido por la extension de dstPath.
|
|
//
|
|
// Solo soporta entrada/salida JPEG y PNG (image stdlib). Formatos modernos como
|
|
// WebP, AVIF o HEIC no estan soportados — retornan error explicito.
|
|
//
|
|
// El algoritmo de resize es nearest-neighbor (sin filtro) para mantener cero
|
|
// dependencias externas. Para apps que necesiten calidad alta usar una libreria
|
|
// como `golang.org/x/image/draw` con BiLinear o CatmullRom.
|
|
func ThumbnailGenerate(srcPath string, dstPath string, maxWidth int, maxHeight int) error {
|
|
if maxWidth <= 0 || maxHeight <= 0 {
|
|
return fmt.Errorf("thumbnail_generate: maxWidth y maxHeight deben ser > 0")
|
|
}
|
|
|
|
srcF, err := os.Open(srcPath)
|
|
if err != nil {
|
|
return fmt.Errorf("thumbnail_generate: open src %s: %w", srcPath, err)
|
|
}
|
|
defer srcF.Close()
|
|
|
|
srcImg, _, err := image.Decode(srcF)
|
|
if err != nil {
|
|
return fmt.Errorf("thumbnail_generate: decode %s: %w", srcPath, err)
|
|
}
|
|
|
|
thumb := resizeNearest(srcImg, maxWidth, maxHeight)
|
|
|
|
if err := os.MkdirAll(filepath.Dir(dstPath), 0o755); err != nil {
|
|
return fmt.Errorf("thumbnail_generate: mkdir dst: %w", err)
|
|
}
|
|
|
|
dstF, err := os.Create(dstPath)
|
|
if err != nil {
|
|
return fmt.Errorf("thumbnail_generate: create dst %s: %w", dstPath, err)
|
|
}
|
|
defer dstF.Close()
|
|
|
|
ext := strings.ToLower(filepath.Ext(dstPath))
|
|
switch ext {
|
|
case ".jpg", ".jpeg":
|
|
return jpeg.Encode(dstF, thumb, &jpeg.Options{Quality: 85})
|
|
case ".png":
|
|
return png.Encode(dstF, thumb)
|
|
default:
|
|
return fmt.Errorf("thumbnail_generate: extension %q no soportada (solo jpg/jpeg/png)", ext)
|
|
}
|
|
}
|
|
|
|
// resizeNearest redimensiona la imagen al maximo (maxW, maxH) manteniendo aspect
|
|
// ratio. Usa interpolacion nearest-neighbor (rapida pero baja calidad).
|
|
func resizeNearest(src image.Image, maxW, maxH int) image.Image {
|
|
srcBounds := src.Bounds()
|
|
srcW := srcBounds.Dx()
|
|
srcH := srcBounds.Dy()
|
|
|
|
if srcW == 0 || srcH == 0 {
|
|
return src
|
|
}
|
|
|
|
// Calcular escala manteniendo aspect ratio
|
|
scaleW := float64(maxW) / float64(srcW)
|
|
scaleH := float64(maxH) / float64(srcH)
|
|
scale := scaleW
|
|
if scaleH < scaleW {
|
|
scale = scaleH
|
|
}
|
|
if scale >= 1.0 {
|
|
// Imagen ya cabe, no agrandar
|
|
return src
|
|
}
|
|
|
|
dstW := int(float64(srcW) * scale)
|
|
dstH := int(float64(srcH) * scale)
|
|
if dstW < 1 {
|
|
dstW = 1
|
|
}
|
|
if dstH < 1 {
|
|
dstH = 1
|
|
}
|
|
|
|
dst := image.NewRGBA(image.Rect(0, 0, dstW, dstH))
|
|
for y := 0; y < dstH; y++ {
|
|
srcY := int(float64(y) / scale)
|
|
for x := 0; x < dstW; x++ {
|
|
srcX := int(float64(x) / scale)
|
|
dst.Set(x, y, src.At(srcBounds.Min.X+srcX, srcBounds.Min.Y+srcY))
|
|
}
|
|
}
|
|
return dst
|
|
}
|