mirror of
https://github.com/Dvorinka/MyClubServer.git
synced 2026-06-04 02:32:57 +00:00
Tomas Dvorak
390 lines
9.9 KiB
Go
390 lines
9.9 KiB
Go
package controllers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"image"
|
|
"image/jpeg"
|
|
"image/png"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/disintegration/imaging"
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
type ImageProcessingController struct{}
|
|
|
|
// ImageProcessRequest represents the request body for image processing
|
|
type ImageProcessRequest struct {
|
|
ImageURL string `json:"image_url"` // URL of image to process
|
|
Operation string `json:"operation"` // crop, resize, rotate, flip, filter
|
|
Width int `json:"width"` // Target width (for resize)
|
|
Height int `json:"height"` // Target height (for resize)
|
|
CropX int `json:"crop_x"` // Crop coordinates
|
|
CropY int `json:"crop_y"`
|
|
CropWidth int `json:"crop_width"`
|
|
CropHeight int `json:"crop_height"`
|
|
Rotation int `json:"rotation"` // Rotation angle (90, 180, 270)
|
|
FlipH bool `json:"flip_h"` // Flip horizontal
|
|
FlipV bool `json:"flip_v"` // Flip vertical
|
|
Brightness float64 `json:"brightness"` // -100 to 100
|
|
Contrast float64 `json:"contrast"` // -100 to 100
|
|
Saturation float64 `json:"saturation"` // -100 to 100
|
|
Blur float64 `json:"blur"` // 0 to 10
|
|
Sharpen float64 `json:"sharpen"` // 0 to 10
|
|
Grayscale bool `json:"grayscale"` // Convert to grayscale
|
|
Quality int `json:"quality"` // JPEG quality 1-100
|
|
}
|
|
|
|
// ProcessImage handles image processing operations
|
|
func (ctrl *ImageProcessingController) ProcessImage(c *gin.Context) {
|
|
var req ImageProcessRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request: " + err.Error()})
|
|
return
|
|
}
|
|
|
|
// Validate quality
|
|
if req.Quality <= 0 || req.Quality > 100 {
|
|
req.Quality = 85 // Default quality
|
|
}
|
|
|
|
// Load image
|
|
img, format, err := ctrl.loadImage(req.ImageURL)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Failed to load image: " + err.Error()})
|
|
return
|
|
}
|
|
|
|
// Apply operations based on request
|
|
processedImg := img
|
|
|
|
// Crop
|
|
if req.CropWidth > 0 && req.CropHeight > 0 {
|
|
processedImg = imaging.Crop(processedImg, image.Rect(
|
|
req.CropX,
|
|
req.CropY,
|
|
req.CropX+req.CropWidth,
|
|
req.CropY+req.CropHeight,
|
|
))
|
|
}
|
|
|
|
// Resize
|
|
if req.Width > 0 || req.Height > 0 {
|
|
width := req.Width
|
|
height := req.Height
|
|
if width == 0 {
|
|
width = 0 // Auto width
|
|
}
|
|
if height == 0 {
|
|
height = 0 // Auto height
|
|
}
|
|
processedImg = imaging.Resize(processedImg, width, height, imaging.Lanczos)
|
|
}
|
|
|
|
// Rotate
|
|
if req.Rotation != 0 {
|
|
switch req.Rotation % 360 {
|
|
case 90, -270:
|
|
processedImg = imaging.Rotate90(processedImg)
|
|
case 180, -180:
|
|
processedImg = imaging.Rotate180(processedImg)
|
|
case 270, -90:
|
|
processedImg = imaging.Rotate270(processedImg)
|
|
}
|
|
}
|
|
|
|
// Flip
|
|
if req.FlipH {
|
|
processedImg = imaging.FlipH(processedImg)
|
|
}
|
|
if req.FlipV {
|
|
processedImg = imaging.FlipV(processedImg)
|
|
}
|
|
|
|
// Brightness
|
|
if req.Brightness != 0 {
|
|
processedImg = imaging.AdjustBrightness(processedImg, req.Brightness)
|
|
}
|
|
|
|
// Contrast
|
|
if req.Contrast != 0 {
|
|
processedImg = imaging.AdjustContrast(processedImg, req.Contrast)
|
|
}
|
|
|
|
// Saturation
|
|
if req.Saturation != 0 {
|
|
processedImg = imaging.AdjustSaturation(processedImg, req.Saturation)
|
|
}
|
|
|
|
// Blur
|
|
if req.Blur > 0 {
|
|
processedImg = imaging.Blur(processedImg, req.Blur)
|
|
}
|
|
|
|
// Sharpen
|
|
if req.Sharpen > 0 {
|
|
processedImg = imaging.Sharpen(processedImg, req.Sharpen)
|
|
}
|
|
|
|
// Grayscale
|
|
if req.Grayscale {
|
|
processedImg = imaging.Grayscale(processedImg)
|
|
}
|
|
|
|
// Save processed image
|
|
outputPath, err := ctrl.saveProcessedImage(processedImg, format, req.Quality)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to save image: " + err.Error()})
|
|
return
|
|
}
|
|
|
|
// Return the new URL
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"url": outputPath,
|
|
"format": format,
|
|
})
|
|
}
|
|
|
|
// loadImage loads an image from a URL or local path
|
|
func (ctrl *ImageProcessingController) loadImage(imageURL string) (image.Image, string, error) {
|
|
// Check if it's a local file path
|
|
if strings.HasPrefix(imageURL, "/uploads/") || strings.HasPrefix(imageURL, "uploads/") {
|
|
// Local file
|
|
localPath := filepath.Join(".", imageURL)
|
|
file, err := os.Open(localPath)
|
|
if err != nil {
|
|
return nil, "", fmt.Errorf("failed to open local file: %w", err)
|
|
}
|
|
defer file.Close()
|
|
|
|
img, format, err := image.Decode(file)
|
|
if err != nil {
|
|
return nil, "", fmt.Errorf("failed to decode image: %w", err)
|
|
}
|
|
return img, format, nil
|
|
}
|
|
|
|
// HTTP URL
|
|
resp, err := http.Get(imageURL)
|
|
if err != nil {
|
|
return nil, "", fmt.Errorf("failed to fetch image: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, "", fmt.Errorf("failed to fetch image: status %d", resp.StatusCode)
|
|
}
|
|
|
|
img, format, err := image.Decode(resp.Body)
|
|
if err != nil {
|
|
return nil, "", fmt.Errorf("failed to decode image: %w", err)
|
|
}
|
|
|
|
return img, format, nil
|
|
}
|
|
|
|
// saveProcessedImage saves the processed image and returns the path
|
|
func (ctrl *ImageProcessingController) saveProcessedImage(img image.Image, format string, quality int) (string, error) {
|
|
// Create uploads directory if it doesn't exist
|
|
uploadsDir := "./uploads"
|
|
if err := os.MkdirAll(uploadsDir, 0755); err != nil {
|
|
return "", fmt.Errorf("failed to create uploads directory: %w", err)
|
|
}
|
|
|
|
// Generate unique filename
|
|
timestamp := time.Now().UnixNano() / int64(time.Millisecond)
|
|
filename := fmt.Sprintf("processed_%d.jpg", timestamp)
|
|
outputPath := filepath.Join(uploadsDir, filename)
|
|
|
|
// Create output file
|
|
outFile, err := os.Create(outputPath)
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to create output file: %w", err)
|
|
}
|
|
defer outFile.Close()
|
|
|
|
// Encode and save
|
|
if format == "png" {
|
|
err = png.Encode(outFile, img)
|
|
} else {
|
|
err = jpeg.Encode(outFile, img, &jpeg.Options{Quality: quality})
|
|
}
|
|
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to encode image: %w", err)
|
|
}
|
|
|
|
// Return relative URL
|
|
return "/uploads/" + filename, nil
|
|
}
|
|
|
|
// CropAndUpload handles image cropping with upload
|
|
func (ctrl *ImageProcessingController) CropAndUpload(c *gin.Context) {
|
|
// Get image from form data
|
|
file, err := c.FormFile("image")
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "No image file provided"})
|
|
return
|
|
}
|
|
|
|
// Get crop parameters
|
|
var cropParams struct {
|
|
X int `json:"x"`
|
|
Y int `json:"y"`
|
|
Width int `json:"width"`
|
|
Height int `json:"height"`
|
|
}
|
|
|
|
cropData := c.PostForm("crop_data")
|
|
if cropData != "" {
|
|
if err := json.Unmarshal([]byte(cropData), &cropParams); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid crop parameters"})
|
|
return
|
|
}
|
|
}
|
|
|
|
quality := 85
|
|
if q := c.PostForm("quality"); q != "" {
|
|
fmt.Sscanf(q, "%d", &quality)
|
|
}
|
|
|
|
maxWidth := 1500
|
|
if mw := c.PostForm("max_width"); mw != "" {
|
|
fmt.Sscanf(mw, "%d", &maxWidth)
|
|
}
|
|
|
|
// Open uploaded file
|
|
src, err := file.Open()
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to open uploaded file"})
|
|
return
|
|
}
|
|
defer src.Close()
|
|
|
|
// Decode image
|
|
img, format, err := image.Decode(src)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid image format"})
|
|
return
|
|
}
|
|
|
|
// Apply crop if parameters provided
|
|
processedImg := img
|
|
if cropParams.Width > 0 && cropParams.Height > 0 {
|
|
processedImg = imaging.Crop(processedImg, image.Rect(
|
|
cropParams.X,
|
|
cropParams.Y,
|
|
cropParams.X+cropParams.Width,
|
|
cropParams.Y+cropParams.Height,
|
|
))
|
|
}
|
|
|
|
// Resize if larger than max width
|
|
bounds := processedImg.Bounds()
|
|
if bounds.Dx() > maxWidth {
|
|
processedImg = imaging.Resize(processedImg, maxWidth, 0, imaging.Lanczos)
|
|
}
|
|
|
|
// Save to uploads
|
|
outputPath, err := ctrl.saveProcessedImage(processedImg, format, quality)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to save processed image"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"url": outputPath,
|
|
})
|
|
}
|
|
|
|
// QuickEdit handles common quick edits in one call
|
|
func (ctrl *ImageProcessingController) QuickEdit(c *gin.Context) {
|
|
var req struct {
|
|
ImageURL string `json:"image_url"`
|
|
Width int `json:"width"`
|
|
Rotation int `json:"rotation"`
|
|
FlipH bool `json:"flip_h"`
|
|
FlipV bool `json:"flip_v"`
|
|
Brightness float64 `json:"brightness"`
|
|
Contrast float64 `json:"contrast"`
|
|
Saturation float64 `json:"saturation"`
|
|
Grayscale bool `json:"grayscale"`
|
|
Quality int `json:"quality"`
|
|
}
|
|
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request"})
|
|
return
|
|
}
|
|
|
|
if req.Quality <= 0 || req.Quality > 100 {
|
|
req.Quality = 85
|
|
}
|
|
|
|
// Load image
|
|
img, format, err := ctrl.loadImage(req.ImageURL)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "Failed to load image: " + err.Error()})
|
|
return
|
|
}
|
|
|
|
processedImg := img
|
|
|
|
// Resize if width specified
|
|
if req.Width > 0 {
|
|
processedImg = imaging.Resize(processedImg, req.Width, 0, imaging.Lanczos)
|
|
}
|
|
|
|
// Rotate
|
|
if req.Rotation != 0 {
|
|
switch req.Rotation % 360 {
|
|
case 90, -270:
|
|
processedImg = imaging.Rotate90(processedImg)
|
|
case 180, -180:
|
|
processedImg = imaging.Rotate180(processedImg)
|
|
case 270, -90:
|
|
processedImg = imaging.Rotate270(processedImg)
|
|
}
|
|
}
|
|
|
|
// Flip
|
|
if req.FlipH {
|
|
processedImg = imaging.FlipH(processedImg)
|
|
}
|
|
if req.FlipV {
|
|
processedImg = imaging.FlipV(processedImg)
|
|
}
|
|
|
|
// Brightness/Contrast/Saturation
|
|
if req.Brightness != 0 {
|
|
processedImg = imaging.AdjustBrightness(processedImg, req.Brightness)
|
|
}
|
|
if req.Contrast != 0 {
|
|
processedImg = imaging.AdjustContrast(processedImg, req.Contrast)
|
|
}
|
|
if req.Saturation != 0 {
|
|
processedImg = imaging.AdjustSaturation(processedImg, req.Saturation)
|
|
}
|
|
|
|
// Grayscale
|
|
if req.Grayscale {
|
|
processedImg = imaging.Grayscale(processedImg)
|
|
}
|
|
|
|
// Save
|
|
outputPath, err := ctrl.saveProcessedImage(processedImg, format, req.Quality)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to save image"})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, gin.H{
|
|
"url": outputPath,
|
|
})
|
|
}
|