Efficient Image Optimization in Laravel for Better Web Performance

In a web application, image upload is essential. However, users often upload high-resolution images that are not optimized for the web, which can slow down the site. Instead of restricting image size during upload, which isn’t user-friendly, you can optimize or resize images in Laravel using the GD extension or ImageMagick, which are available on most hosting providers.

Here’s a PHP class that optimizes images for the web:

class ImageOptimize {
    /**
     * Resize and optimize an image.
     *
     * @param string $file The path to the image file.
     * @param int $w The desired width of the image.
     * @param int $h The desired height of the image.
     * @param bool $crop Whether to crop the image to the exact dimensions.
     * @return string The optimized image data.
     * @throws \Exception If an error occurs during processing.
     */
    public static function resize_image(string $file, int $w, int $h, bool $crop = false): string {
        [$width, $height, $type] = getimagesize($file);
        $r = $width / $height;
        if ($crop) {
            if ($width > $height) {
                $width = (int) ceil($width - ($width * abs($r - $w / $h)));
            } else {
                $height = (int) ceil($height - ($height * abs($r - $w / $h)));
            }
            $newwidth = $w;
            $newheight = $h;
        } else {
            if ($w / $h > $r) {
                $newwidth = (int) ($h * $r);
                $newheight = $h;
            } else {
                $newheight = (int) ($w / $r);
                $newwidth = $w;
            }
        }

        $src = self::createImageResource($type, $file);
        $dst = imagecreatetruecolor($newwidth, $newheight);

        // Preserve transparency for PNG and GIF
        if ($type === IMAGETYPE_PNG || $type === IMAGETYPE_GIF) {
            imagecolortransparent($dst, imagecolorallocatealpha($dst, 0, 0, 0, 127));
            imagealphablending($dst, false);
            imagesavealpha($dst, true);
        }

        imagecopyresampled($dst, $src, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);

        ob_start();
        self::outputImageResource($type, $dst);
        $image_data = ob_get_contents();
        ob_end_clean();

        imagedestroy($src);
        imagedestroy($dst);

        return $image_data;
    }

    /**
     * Create an image resource from a file.
     *
     * @param int $type The type of the image.
     * @param string $file The path to the image file.
     * @return resource The image resource.
     * @throws \Exception If the image type is unsupported.
     */
    private static function createImageResource(int $type, string $file) {
        switch ($type) {
            case IMAGETYPE_JPEG:
                return imagecreatefromjpeg($file);
            case IMAGETYPE_PNG:
                return imagecreatefrompng($file);
            case IMAGETYPE_GIF:
                return imagecreatefromgif($file);
            default:
                throw new \Exception("Unsupported image type");
        }
    }

    /**
     * Output an image resource.
     *
     * @param int $type The type of the image.
     * @param resource $dst The image resource.
     */
    private static function outputImageResource(int $type, $dst) {
        switch ($type) {
            case IMAGETYPE_JPEG:
                imagejpeg($dst, null, 80);
                break;
            case IMAGETYPE_PNG:
                imagepng($dst);
                break;
            case IMAGETYPE_GIF:
                imagegif($dst);
                break;
        }
    }
}

The resize_image function in the ImageOptimize class resizes and optimizes an image.
It calculates the new dimensions based on the aspect ratio and whether cropping is needed.
It creates an image resource from the original file, resamples it to the new size, and preserves transparency for PNG and GIF images.
The optimized image is output to a string and returned.

To use this class in a controller for image uploads, you can do the following:

if ($request->hasFile('my_image')) {
    $image = $request->file('my_image');
    $optimizedImage = ImageOptimize::resize_image($image->getPathname(), 1920, 1920);
    $imageName = Str::uuid() . '_' . $image->getClientOriginalName();

    $imagePath = public_path('images' . '/' . $imageName);
    File::put($imagePath, $optimizedImage);

    // $image->move(public_path('images'), $imageName);
    $model->thumbnail_image = 'images/' . $imageName;
}

This code checks if a thumbnail image file is uploaded.
It optimizes the image using the ImageOptimize::resize_image function to resize it to a maximum of 1920×1920 pixels.
A unique name is generated for the image using Str::uuid() combined with the original image name.
The optimized image is saved to the public/images directory.
The path to the image is stored in the model.

This approach ensures that images are optimized for the web, improving the performance of your site without inconveniencing users.

Also we can use trait so that we can use it in any class. Here below showing the trait.

<?php

namespace App\Traits;

use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Spatie\Image\Enums\ImageDriver;
use Spatie\Image\Image;

trait ImageTrait
{
    public function saveImage($image, $path, $edit = null, $height = null, $width = null)
    {
        if ($image) {
            if ($edit) {
                $this->deleteFile($edit);
            }
            $name = Str::uuid() . '.' . $image->getClientOriginalExtension();
            $path = 'uploads/images/' . $path . '/';

            if (!is_dir(public_path($path))) {
                mkdir($path, 0777, true);
            }

            $img = Image::useImageDriver(ImageDriver::Gd)->loadFile($image);

            if (!$width) {
                $width = $img->getWidth();
                if ($width > 600) {
                    $width = 600;
                }
            }
            if ($height) {
                $img->resize($width, $height);
            } else {
                $img->width($width);
            }
            $img->save($path . $name);
            return $path . $name;
        } else
            return $edit;
    }

    public function deleteFile($file): bool
    {
        return $file && Storage::disk()->delete($file);
    }

    public function uploadFiles($file, $path): string
    {
        $file_name = Str::uuid() . '.' . $file->getClientOriginalExtension();
        $path = 'uploads/' . $path . '/';
        if (!is_dir(public_path($path))) {
            mkdir($path, 0777, true);
        }
        Storage::disk()->put($path.$file_name, file_get_contents($file));
        return $path.$file_name;
    }
}