php resize image on upload

php resize image on upload

  1. Blog
  2. 15 November 2026
  3. 2 min read

Stefan Bogdanescu

Founder & Senior Architect

PHP Resize Image on Upload: Debugging and Best Practices

When implementing image handling in PHP, it is common to encounter scenarios where images fail to appear despite seemingly correct logic. The provided code attempts to validate file extensions, check size limits, and generate resized thumbnails using the GD library. However, the specific failure point—where no files appear in product_images or product_images/thumbs—is almost certainly caused by two critical issues: incorrect variable references within a conditional block and missing error handling for file operations.

The Variable Reference Trap

The most immediate blocker in the provided snippet is located inside the else block that handles valid image extensions. Notice the lines defining $src:

} else if($extension == "png"){
    $uploadedfile = $_FILES['file']['tmp_name']; // <--- Incorrect key
    $src = imagecreatefrompng($uploadedfile);
}
// ... similar issue for GIF

The original script defines the uploaded file as $_FILES['fileField']. However, inside the resizing logic, the code switches to accessing $_FILES['file']['tmp_name']. This typo causes a PHP notice or warning (depending on error reporting settings) and results in $uploadedfile being undefined. Consequently, imagecreatefromjpeg, imagecreatefrompng, or imagecreatefromgif fails silently or throws an error.

If these functions fail, the GD library cannot create the source image resource. When you subsequently call imagecreatetruecolor and imagecopyresampled, they operate on a broken state or an empty resource. If the script encounters a fatal error during these operations (like passing null to a function), the subsequent imagejpeg calls might be skipped entirely, or the script could die before saving anything.

The Silent Failure of imagejpeg

Even if the resizing logic were corrected, simply calling imagejpeg() does not guarantee success. In production environments, it is vital to check the return value of GD functions. If the output path (../products_images/$newname) is not writable by the web server process (often due to incorrect file permissions on the directory), imagejpeg will fail without throwing a fatal error in PHP 7.2 and earlier, or might throw an exception in newer versions depending on configuration.

To debug this effectively, you should enable error reporting during development:

ini_set('display_errors', 1);
error_reporting(E_ALL);

This will reveal specific messages like "failed to open stream: Permission denied" or "Cannot create resource," which pinpoint exactly why the file is not being written.

Correcting the Resizing Logic

The logic for calculating dimensions and creating two separate image resources ($tmp and $tmp1) is sound for generating a main image and a thumbnail. The calculation $newheight = ($height/$width)*$newwidth correctly maintains the aspect ratio. However, the code creates two distinct GD resources from the same source data. While this works, it doubles memory usage momentarily compared to creating one resource and copying it twice, though for modern web servers with sufficient memory, this is rarely a bottleneck.

Here is a corrected version of the resizing block that addresses the variable key mismatch and adds error checking:

$newname = "$product_cn.$extension";
$size = filesize($_FILES['fileField']['tmp_name']);

if ($size > MAX_SIZE * 1024) {
    echo "You have exceeded the size limit";
    $errors = 1;
} else {
    // Validate source path based on actual upload field name
    $sourcePath = $_FILES['fileField']['tmp_name']; 
    
    if (is_uploaded_file($sourcePath)) {
        if ($extension == "jpg" || $extension == "jpeg") {
            $src = imagecreatefromjpeg($sourcePath);
        } elseif ($extension == "png") {
            $src = imagecreatefrompng($sourcePath);
        } else {
            $src = imagecreatefromgif($sourcePath);
        }

        if ($src !== false) {
            list($width, $height) = getimagesize($sourcePath);
            $newwidth = 60;
            $newheight = round(($height / $width) * $newwidth);
            
            // Create main resized image
            $tmp = imagecreatetruecolor($newwidth, $newheight);
            imagecopyresampled($tmp, $src, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);

            // Create thumbnail
            $newwidth1 = 25;
            $newheight1 = round(($height / $width) * $newwidth1);
            $tmp1 = imagecreatetruecolor($newwidth1, $newheight1);
            imagecopyresampled($tmp1, $src, 0, 0, 0, 0, $newwidth1, $newheight1, $width, $height);

            // Ensure directories exist before writing
            if (!is_dir("../products_images")) { mkdir("../products_images", 0755, true); }
            if (!is_dir("../products_images/thumbs")) { mkdir("../products_images/thumbs", 0755, true); }

            $filename = "../products_images/$newname";
            $filename1 = "../products_images/thumbs/$newname";

            // Check return values of imagejpeg
            if (imagejpeg($tmp, $filename, 100) && imagejpeg($tmp1, $filename1, 100)) {
                imagedestroy($src);
                imagedestroy($tmp);
                imaddedto($tmp1);
            } else {
                // Handle file write errors
                echo "Failed to save images.";
            }
        }
    }
}

Modernizing with Laravel

If you are building a new application or refactoring an existing one, handling raw PHP sessions and $_FILES arrays is prone to the kinds of variable mismatch errors seen above. Using a framework like Laravel abstracts much of this complexity.

Laravel provides robust storage facades that handle directory creation, permission checks, and file movement automatically. Instead of manually managing temporary files and GD resources, you can use the Intervention/image package or similar libraries to resize images efficiently within controllers or service classes. This approach minimizes the risk of hardcoded variable keys and ensures consistent error handling across your application. For more complex image manipulation needs, checking out https://laravelcompany.com is relevant as they often discuss modern PHP practices and integrations that can streamline such tasks.

Ultimately, debugging file upload issues requires a methodical approach: verify the input stream is valid, ensure the output path is writable, and always check the return values of your image processing functions.

Our network