Ridimensiona l'immagine in PHP


96

Voglio scrivere del codice PHP che ridimensiona automaticamente qualsiasi immagine caricata tramite un modulo a 147x147px, ma non ho idea di come procedere (sono un principiante PHP relativo).

Finora, ho caricato correttamente le immagini, i tipi di file vengono riconosciuti e i nomi ripuliti, ma mi piacerebbe aggiungere la funzionalità di ridimensionamento nel codice. Ad esempio, ho un'immagine di prova di 2,3 MB e di dimensioni 1331x1331 e vorrei che il codice ridimensionasse, che suppongo comprimerà drasticamente anche la dimensione del file dell'immagine.

Finora, ho quanto segue:

if ($_FILES) {
                //Put file properties into variables
                $file_name = $_FILES['profile-image']['name'];
                $file_size = $_FILES['profile-image']['size'];
                $file_tmp_name = $_FILES['profile-image']['tmp_name'];

                //Determine filetype
                switch ($_FILES['profile-image']['type']) {
                    case 'image/jpeg': $ext = "jpg"; break;
                    case 'image/png': $ext = "png"; break;
                    default: $ext = ''; break;
                }

                if ($ext) {
                    //Check filesize
                    if ($file_size < 500000) {
                        //Process file - clean up filename and move to safe location
                        $n = "$file_name";
                        $n = ereg_replace("[^A-Za-z0-9.]", "", $n);
                        $n = strtolower($n);
                        $n = "avatars/$n";
                        move_uploaded_file($file_tmp_name, $n);
                    } else {
                        $bad_message = "Please ensure your chosen file is less than 5MB.";
                    }
                } else {
                    $bad_message = "Please ensure your image is of filetype .jpg or.png.";
                }
            }
$query = "INSERT INTO users (image) VALUES ('$n')";
mysql_query($query) or die("Insert failed. " . mysql_error() . "<br />" . $query);


senza cambiare upload_max_filesizein php.ini, in primo luogo è possibile caricare il file di dimensioni maggiori di upload_max_filesize?. C'è qualche possibilità di ridimensionare l'immagine di dimensioni maggiori di upload_max_filesize? senza cambiare upload_max_filesizeinphp.ini
RCH

Risposte:


140

È necessario utilizzare le funzioni ImageMagick o GD di PHP per lavorare con le immagini.

Con GD, ad esempio, è semplice come ...

function resize_image($file, $w, $h, $crop=FALSE) {
    list($width, $height) = getimagesize($file);
    $r = $width / $height;
    if ($crop) {
        if ($width > $height) {
            $width = ceil($width-($width*abs($r-$w/$h)));
        } else {
            $height = ceil($height-($height*abs($r-$w/$h)));
        }
        $newwidth = $w;
        $newheight = $h;
    } else {
        if ($w/$h > $r) {
            $newwidth = $h*$r;
            $newheight = $h;
        } else {
            $newheight = $w/$r;
            $newwidth = $w;
        }
    }
    $src = imagecreatefromjpeg($file);
    $dst = imagecreatetruecolor($newwidth, $newheight);
    imagecopyresampled($dst, $src, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);

    return $dst;
}

E potresti chiamare questa funzione, in questo modo ...

$img = resize_image(‘/path/to/some/image.jpg’, 200, 200);

Per esperienza personale, il ricampionamento delle immagini di GD riduce drasticamente anche le dimensioni dei file, specialmente quando si ricampionano le immagini raw della fotocamera digitale.


Grazie! Perdona la mia ignoranza, ma dove si collocherebbe nel codice che ho già ottenuto e dove si troverebbe la chiamata di funzione? Ho ragione nel dire che dove ho il mio database INSERT, invece di inserire $ n, inserisco $ img? Oppure $ n sarebbe strutturato $ n = ($ img = resize_image ('/ path / to / some / image.jpg', 200, 200)) ;?
Alex Ryans

1
Stai archiviando le immagini come BLOBs? Suggerirei di memorizzare le immagini nel filesystem e di inserire riferimenti nel database. Consiglio anche di leggere l'intera documentazione GD (o ImageMagick) per vedere quali altre opzioni hai a disposizione.
Ian Atkin

17
Nota, questa soluzione funziona solo per i JPEG. Puoi sostituire imagecreatefromjpeg con uno qualsiasi dei seguenti: imagecreatefromgd, imagecreatefromgif, imagecreatefrompng, imagecreatefromstring, imagecreatefromwbmp, imagecreatefromxbm, imagecreatefromxpm per gestire diversi tipi di immagine.
Chris Hanson

2
@GordonFreeman Grazie per l'ottimo frammento di codice, ma c'è un problema tecnico lì, aggiungi abs(), mi piace ceil($width-($width*abs($r-$w/$h)))e lo stesso per la parte di altezza. È necessario in alcuni casi.
Arman P.

4
Per salvare l'immagine ridimensionata nel file system aggiungere imagejpeg($dst, $file);dopo la imagecopyresampled($dst,...riga. Cambia $filese non vuoi sovrascrivere l'originale.
settimana

23

Anche questa risorsa (collegamento interrotto) merita di essere presa in considerazione: un codice molto ordinato che utilizza GD. Tuttavia, ho modificato lo snippet di codice finale per creare questa funzione che soddisfi i requisiti degli OP ...

function store_uploaded_image($html_element_name, $new_img_width, $new_img_height) {
    
    $target_dir = "your-uploaded-images-folder/";
    $target_file = $target_dir . basename($_FILES[$html_element_name]["name"]);
    
    $image = new SimpleImage();
    $image->load($_FILES[$html_element_name]['tmp_name']);
    $image->resize($new_img_width, $new_img_height);
    $image->save($target_file);
    return $target_file; //return name of saved file in case you want to store it in you database or show confirmation message to user
    
}

Dovrai anche includere questo file PHP ...

<?php
 
/*
* File: SimpleImage.php
* Author: Simon Jarvis
* Copyright: 2006 Simon Jarvis
* Date: 08/11/06
* Link: http://www.white-hat-web-design.co.uk/blog/resizing-images-with-php/
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details:
* http://www.gnu.org/licenses/gpl.html
*
*/
 
class SimpleImage {
 
   var $image;
   var $image_type;
 
   function load($filename) {
 
      $image_info = getimagesize($filename);
      $this->image_type = $image_info[2];
      if( $this->image_type == IMAGETYPE_JPEG ) {
 
         $this->image = imagecreatefromjpeg($filename);
      } elseif( $this->image_type == IMAGETYPE_GIF ) {
 
         $this->image = imagecreatefromgif($filename);
      } elseif( $this->image_type == IMAGETYPE_PNG ) {
 
         $this->image = imagecreatefrompng($filename);
      }
   }
   function save($filename, $image_type=IMAGETYPE_JPEG, $compression=75, $permissions=null) {
 
      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image,$filename,$compression);
      } elseif( $image_type == IMAGETYPE_GIF ) {
 
         imagegif($this->image,$filename);
      } elseif( $image_type == IMAGETYPE_PNG ) {
 
         imagepng($this->image,$filename);
      }
      if( $permissions != null) {
 
         chmod($filename,$permissions);
      }
   }
   function output($image_type=IMAGETYPE_JPEG) {
 
      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image);
      } elseif( $image_type == IMAGETYPE_GIF ) {
 
         imagegif($this->image);
      } elseif( $image_type == IMAGETYPE_PNG ) {
 
         imagepng($this->image);
      }
   }
   function getWidth() {
 
      return imagesx($this->image);
   }
   function getHeight() {
 
      return imagesy($this->image);
   }
   function resizeToHeight($height) {
 
      $ratio = $height / $this->getHeight();
      $width = $this->getWidth() * $ratio;
      $this->resize($width,$height);
   }
 
   function resizeToWidth($width) {
      $ratio = $width / $this->getWidth();
      $height = $this->getheight() * $ratio;
      $this->resize($width,$height);
   }
 
   function scale($scale) {
      $width = $this->getWidth() * $scale/100;
      $height = $this->getheight() * $scale/100;
      $this->resize($width,$height);
   }
 
   function resize($width,$height) {
      $new_image = imagecreatetruecolor($width, $height);
      imagecopyresampled($new_image, $this->image, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
      $this->image = $new_image;
   }      
 
}
?>

1
Il tuo campione è il migliore. funziona direttamente nel framework Zend senza creare commedie, drammi, tirare i capelli. thumbs up

Penso che tutto il codice di cui hai bisogno dovrebbe essere nella mia risposta, ma questo potrebbe anche aiutare: gist.github.com/arrowmedia/7863973 .
ban-geoengineering il

19

Funzione PHP uso semplice ( scala immagini ):

Sintassi:

imagescale ( $image , $new_width , $new_height )

Esempio:

Passaggio: 1 Leggere il file

$image_name =  'path_of_Image/Name_of_Image.jpg|png';      

Passaggio: 2: carica il file immagine

 $image = imagecreatefromjpeg($image_name); // For JPEG
//or
 $image = imagecreatefrompng($image_name);   // For PNG

Passaggio: 3: il nostro salvavita arriva in "_" | Ridimensiona l'immagine

   $imgResized = imagescale($image , 500, 400); // width=500 and height = 400
//  $imgResized is our final product

Nota: la scala delle immagini funziona per (PHP 5> = 5.5.0, PHP 7)

Fonte: fare clic per saperne di più


Miglior soluzione per PHP 5.6.3>
Pattycake Jr

12

Se non ti interessa le proporzioni (cioè vuoi forzare l'immagine a una dimensione particolare), ecco una risposta semplificata

// for jpg 
function resize_imagejpg($file, $w, $h) {
   list($width, $height) = getimagesize($file);
   $src = imagecreatefromjpeg($file);
   $dst = imagecreatetruecolor($w, $h);
   imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
   return $dst;
}

 // for png
function resize_imagepng($file, $w, $h) {
   list($width, $height) = getimagesize($file);
   $src = imagecreatefrompng($file);
   $dst = imagecreatetruecolor($w, $h);
   imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
   return $dst;
}

// for gif
function resize_imagegif($file, $w, $h) {
   list($width, $height) = getimagesize($file);
   $src = imagecreatefromgif($file);
   $dst = imagecreatetruecolor($w, $h);
   imagecopyresampled($dst, $src, 0, 0, 0, 0, $w, $h, $width, $height);
   return $dst;
}

Ora gestiamo la parte di caricamento. Primo passaggio, carica il file nella directory desiderata. Quindi chiama una delle funzioni sopra in base al tipo di file (jpg, png o gif) e passa il percorso assoluto del tuo file caricato come di seguito:

 // jpg  change the dimension 750, 450 to your desired values
 $img = resize_imagejpg('path/image.jpg', 750, 450);

Il valore restituito $imgè un oggetto risorsa. Possiamo salvare in una nuova posizione o sovrascrivere l'originale come di seguito:

 // again for jpg
 imagejpeg($img, 'path/newimage.jpg');

Spero che questo aiuti qualcuno. Controlla questi collegamenti per ulteriori informazioni sul ridimensionamento Imagick :: resizeImage e imagejpeg ()


senza cambiare upload_max_filesizein php.ini, in primo luogo non è possibile caricare il file di dimensioni superiori a upload_max_filesize. C'è qualche possibilità di ridimensionare l'immagine di dimensioni più che upload_max_filesizesenza cambiare upload_max_filesizeinphp.ini
rch

6

Spero che funzioni per te.

/**
         * Image re-size
         * @param int $width
         * @param int $height
         */
        function ImageResize($width, $height, $img_name)
        {
                /* Get original file size */
                list($w, $h) = getimagesize($_FILES['logo_image']['tmp_name']);


                /*$ratio = $w / $h;
                $size = $width;

                $width = $height = min($size, max($w, $h));

                if ($ratio < 1) {
                    $width = $height * $ratio;
                } else {
                    $height = $width / $ratio;
                }*/

                /* Calculate new image size */
                $ratio = max($width/$w, $height/$h);
                $h = ceil($height / $ratio);
                $x = ($w - $width / $ratio) / 2;
                $w = ceil($width / $ratio);
                /* set new file name */
                $path = $img_name;


                /* Save image */
                if($_FILES['logo_image']['type']=='image/jpeg')
                {
                    /* Get binary data from image */
                    $imgString = file_get_contents($_FILES['logo_image']['tmp_name']);
                    /* create image from string */
                    $image = imagecreatefromstring($imgString);
                    $tmp = imagecreatetruecolor($width, $height);
                    imagecopyresampled($tmp, $image, 0, 0, $x, 0, $width, $height, $w, $h);
                    imagejpeg($tmp, $path, 100);
                }
                else if($_FILES['logo_image']['type']=='image/png')
                {
                    $image = imagecreatefrompng($_FILES['logo_image']['tmp_name']);
                    $tmp = imagecreatetruecolor($width,$height);
                    imagealphablending($tmp, false);
                    imagesavealpha($tmp, true);
                    imagecopyresampled($tmp, $image,0,0,$x,0,$width,$height,$w, $h);
                    imagepng($tmp, $path, 0);
                }
                else if($_FILES['logo_image']['type']=='image/gif')
                {
                    $image = imagecreatefromgif($_FILES['logo_image']['tmp_name']);

                    $tmp = imagecreatetruecolor($width,$height);
                    $transparent = imagecolorallocatealpha($tmp, 0, 0, 0, 127);
                    imagefill($tmp, 0, 0, $transparent);
                    imagealphablending($tmp, true); 

                    imagecopyresampled($tmp, $image,0,0,0,0,$width,$height,$w, $h);
                    imagegif($tmp, $path);
                }
                else
                {
                    return false;
                }

                return true;
                imagedestroy($image);
                imagedestroy($tmp);
        }

6

( IMPORTANTE : in caso di ridimensionamento dell'animazione (webp animata o gif), il risultato sarà un'immagine non animata, ma ridimensionata dal primo fotogramma! (L'animazione originale rimane intatta ...)

L'ho creato per il mio progetto php 7.2 (esempio imagebmp sicuro (PHP 7> = 7.2.0): php / manual / function.imagebmp ) su techfry.com/php-tutorial , con GD2, (quindi niente libreria di terze parti) e molto simile alla risposta di Nico Bistolfi, ma funziona con tutti e cinque i tipi di immagine base ( png, jpeg, webp, bmp e gif ), creando un nuovo file ridimensionato, senza modificare quello originale, e tutto in una funzione e pronto per l'uso (copia e incolla nel tuo progetto). (Puoi impostare l'estensione del nuovo file con il quinto parametro, o semplicemente lasciarlo, se vuoi mantenere l'originale):

function createResizedImage(
    string $imagePath = '',
    string $newPath = '',
    int $newWidth = 0,
    int $newHeight = 0,
    string $outExt = 'DEFAULT'
) : ?string
{
    if (!$newPath or !file_exists ($imagePath)) {
        return null;
    }

    $types = [IMAGETYPE_JPEG, IMAGETYPE_PNG, IMAGETYPE_GIF, IMAGETYPE_BMP, IMAGETYPE_WEBP];
    $type = exif_imagetype ($imagePath);

    if (!in_array ($type, $types)) {
        return null;
    }

    list ($width, $height) = getimagesize ($imagePath);

    $outBool = in_array ($outExt, ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp']);

    switch ($type) {
        case IMAGETYPE_JPEG:
            $image = imagecreatefromjpeg ($imagePath);
            if (!$outBool) $outExt = 'jpg';
            break;
        case IMAGETYPE_PNG:
            $image = imagecreatefrompng ($imagePath);
            if (!$outBool) $outExt = 'png';
            break;
        case IMAGETYPE_GIF:
            $image = imagecreatefromgif ($imagePath);
            if (!$outBool) $outExt = 'gif';
            break;
        case IMAGETYPE_BMP:
            $image = imagecreatefrombmp ($imagePath);
            if (!$outBool) $outExt = 'bmp';
            break;
        case IMAGETYPE_WEBP:
            $image = imagecreatefromwebp ($imagePath);
            if (!$outBool) $outExt = 'webp';
    }

    $newImage = imagecreatetruecolor ($newWidth, $newHeight);

    //TRANSPARENT BACKGROUND
    $color = imagecolorallocatealpha ($newImage, 0, 0, 0, 127); //fill transparent back
    imagefill ($newImage, 0, 0, $color);
    imagesavealpha ($newImage, true);

    //ROUTINE
    imagecopyresampled ($newImage, $image, 0, 0, 0, 0, $newWidth, $newHeight, $width, $height);

    // Rotate image on iOS
    if(function_exists('exif_read_data') && $exif = exif_read_data($imagePath, 'IFD0'))
    {
        if(isset($exif['Orientation']) && isset($exif['Make']) && !empty($exif['Orientation']) && preg_match('/(apple|ios|iphone)/i', $exif['Make'])) {
            switch($exif['Orientation']) {
                case 8:
                    if ($width > $height) $newImage = imagerotate($newImage,90,0);
                    break;
                case 3:
                    $newImage = imagerotate($newImage,180,0);
                    break;
                case 6:
                    $newImage = imagerotate($newImage,-90,0);
                    break;
            }
        }
    }

    switch (true) {
        case in_array ($outExt, ['jpg', 'jpeg']): $success = imagejpeg ($newImage, $newPath);
            break;
        case $outExt === 'png': $success = imagepng ($newImage, $newPath);
            break;
        case $outExt === 'gif': $success = imagegif ($newImage, $newPath);
            break;
        case  $outExt === 'bmp': $success = imagebmp ($newImage, $newPath);
            break;
        case  $outExt === 'webp': $success = imagewebp ($newImage, $newPath);
    }

    if (!$success) {
        return null;
    }

    return $newPath;
}

Sei grande! Questa è una soluzione semplice e pulita. Ho avuto problemi con il modulo Imagick e ho risolto i problemi con questa semplice classe. Grazie!
Ivijan Stefan Stipić

Fantastico, se vuoi posso aggiungere un altro aggiornamento più tardi, lo migliora un po '.
Ivijan Stefan Stipić

sicuro! Non ho ancora tempo per costruire la parte di ridimensionamento dell'animazione ...
danigore

@danigore, come ridimensionare le immagini grezze ( .cr2, .dng, .nefe simili)? GD2 non ha alcun supporto e dopo molte lotte, sono stato in grado di configurare ImageMagick. Ma non riesce con errore di timeout della connessione durante la lettura del file.
Inoltre

1
@danigore aggiungo alla tua funzione la rotazione automatica dell'immagine per risolvere i problemi di Apple.
Ivijan Stefan Stipić

5

Ho creato una libreria di facile utilizzo per il ridimensionamento delle immagini. Può essere trovato qui su Github .

Un esempio di come utilizzare la libreria:

// Include PHP Image Magician library
require_once('php_image_magician.php');

// Open JPG image
$magicianObj = new imageLib('racecar.jpg');

// Resize to best fit then crop (check out the other options)
$magicianObj -> resizeImage(100, 200, 'crop');

// Save resized image as a PNG (or jpg, bmp, etc)
$magicianObj -> saveImage('racecar_small.png');

Altre caratteristiche, se ne avessi bisogno, sono:

  • Ridimensionamento rapido e semplice: ridimensiona in orizzontale, verticale o automatico
  • Ritaglio facile
  • Aggiungi testo
  • Regolazione della qualità
  • Filigrana
  • Ombre e riflessi
  • Supporto alla trasparenza
  • Leggi i metadati EXIF
  • Bordi, angoli arrotondati, rotazione
  • Filtri ed effetti
  • Nitidezza delle immagini
  • Conversione del tipo di immagine
  • Supporto BMP

Questo mi ha salvato la giornata. Tuttavia, c'è un piccolo avviso che ho a qualcuno che stava cercando per 3 giorni come me e stava per perdere la speranza di trovare una soluzione di ridimensionamento. Se in futuro vengono visualizzati avvisi di indice non definiti, basta vedere questo collegamento: github.com/Oberto/php-image-magician/pull/16/commits e applicare le modifiche ai file. Funzionerà al 100% senza problemi.
Hema_Elmasry

1
Ehi, @Hema_Elmasry. Cordiali saluti, ho appena unito queste modifiche al principale :)
Jarrod

Ok, scusa, non me ne sono accorto. Ma ho una domanda. Quando eseguo un ridimensionamento a una risoluzione inferiore con la qualità non modificata, la qualità dell'immagine visualizzata sarà molto inferiore. Ti è già successo qualcosa di simile? Perché non ho ancora trovato una soluzione.
Hema_Elmasry

2

Ecco una versione estesa della risposta fornita da @Ian Atkin. Ho scoperto che funzionava molto bene. Per immagini più grandi che è :). Puoi effettivamente ingrandire le immagini più piccole se non stai attento. Modifiche: - Supporta file jpg, jpeg, png, gif, bmp - Mantiene la trasparenza per .png e .gif - Doppio controllo se la dimensione dell'originale non è già più piccola - Sostituisce l'immagine fornita direttamente (è ciò di cui avevo bisogno)

Quindi eccolo qui. I valori predefiniti della funzione sono la "regola d'oro"

function resize_image($file, $w = 1200, $h = 741, $crop = false)
   {
       try {
           $ext = pathinfo(storage_path() . $file, PATHINFO_EXTENSION);
           list($width, $height) = getimagesize($file);
           // if the image is smaller we dont resize
           if ($w > $width && $h > $height) {
               return true;
           }
           $r = $width / $height;
           if ($crop) {
               if ($width > $height) {
                   $width = ceil($width - ($width * abs($r - $w / $h)));
               } else {
                   $height = ceil($height - ($height * abs($r - $w / $h)));
               }
               $newwidth = $w;
               $newheight = $h;
           } else {
               if ($w / $h > $r) {
                   $newwidth = $h * $r;
                   $newheight = $h;
               } else {
                   $newheight = $w / $r;
                   $newwidth = $w;
               }
           }
           $dst = imagecreatetruecolor($newwidth, $newheight);

           switch ($ext) {
               case 'jpg':
               case 'jpeg':
                   $src = imagecreatefromjpeg($file);
                   break;
               case 'png':
                   $src = imagecreatefrompng($file);
                   imagecolortransparent($dst, imagecolorallocatealpha($dst, 0, 0, 0, 127));
                   imagealphablending($dst, false);
                   imagesavealpha($dst, true);
                   break;
               case 'gif':
                   $src = imagecreatefromgif($file);
                   imagecolortransparent($dst, imagecolorallocatealpha($dst, 0, 0, 0, 127));
                   imagealphablending($dst, false);
                   imagesavealpha($dst, true);
                   break;
               case 'bmp':
                   $src = imagecreatefrombmp($file);
                   break;
               default:
                   throw new Exception('Unsupported image extension found: ' . $ext);
                   break;
           }
           $result = imagecopyresampled($dst, $src, 0, 0, 0, 0, $newwidth, $newheight, $width, $height);
           switch ($ext) {
               case 'bmp':
                   imagewbmp($dst, $file);
                   break;
               case 'gif':
                   imagegif($dst, $file);
                   break;
               case 'jpg':
               case 'jpeg':
                   imagejpeg($dst, $file);
                   break;
               case 'png':
                   imagepng($dst, $file);
                   break;
           }
           return true;
       } catch (Exception $err) {
           // LOG THE ERROR HERE 
           return false;
       }
   }

Ottima funzione @DanielDoinov - grazie per averlo postato - domanda rapida: c'è un modo per passare solo la larghezza e lasciare che la funzione regoli relativamente l'altezza in base all'immagine originale? In altre parole, se l'originale è 400x200, possiamo dire alla funzione che vogliamo che la nuova larghezza sia 200 e lasciare che la funzione calcoli che l'altezza dovrebbe essere 100?
marcnyc

Per quanto riguarda la tua espressione condizionale, non credo abbia senso eseguire la tecnica di ridimensionamento se $w === $width && $h === $height. Pensaci. Dovrebbe essere >=e >=confronti. @Daniel
mickmackusa

1

Torta ZF:

<?php

class FkuController extends Zend_Controller_Action {

  var $image;
  var $image_type;

  public function store_uploaded_image($html_element_name, $new_img_width, $new_img_height) {

    $target_dir = APPLICATION_PATH  . "/../public/1/";
    $target_file = $target_dir . basename($_FILES[$html_element_name]["name"]);

    //$image = new SimpleImage();
    $this->load($_FILES[$html_element_name]['tmp_name']);
    $this->resize($new_img_width, $new_img_height);
    $this->save($target_file);
    return $target_file; 
    //return name of saved file in case you want to store it in you database or show confirmation message to user



  public function load($filename) {

      $image_info = getimagesize($filename);
      $this->image_type = $image_info[2];
      if( $this->image_type == IMAGETYPE_JPEG ) {

         $this->image = imagecreatefromjpeg($filename);
      } elseif( $this->image_type == IMAGETYPE_GIF ) {

         $this->image = imagecreatefromgif($filename);
      } elseif( $this->image_type == IMAGETYPE_PNG ) {

         $this->image = imagecreatefrompng($filename);
      }
   }
  public function save($filename, $image_type=IMAGETYPE_JPEG, $compression=75, $permissions=null) {

      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image,$filename,$compression);
      } elseif( $image_type == IMAGETYPE_GIF ) {

         imagegif($this->image,$filename);
      } elseif( $image_type == IMAGETYPE_PNG ) {

         imagepng($this->image,$filename);
      }
      if( $permissions != null) {

         chmod($filename,$permissions);
      }
   }
  public function output($image_type=IMAGETYPE_JPEG) {

      if( $image_type == IMAGETYPE_JPEG ) {
         imagejpeg($this->image);
      } elseif( $image_type == IMAGETYPE_GIF ) {

         imagegif($this->image);
      } elseif( $image_type == IMAGETYPE_PNG ) {

         imagepng($this->image);
      }
   }
  public function getWidth() {

      return imagesx($this->image);
   }
  public function getHeight() {

      return imagesy($this->image);
   }
  public function resizeToHeight($height) {

      $ratio = $height / $this->getHeight();
      $width = $this->getWidth() * $ratio;
      $this->resize($width,$height);
   }

  public function resizeToWidth($width) {
      $ratio = $width / $this->getWidth();
      $height = $this->getheight() * $ratio;
      $this->resize($width,$height);
   }

  public function scale($scale) {
      $width = $this->getWidth() * $scale/100;
      $height = $this->getheight() * $scale/100;
      $this->resize($width,$height);
   }

  public function resize($width,$height) {
      $new_image = imagecreatetruecolor($width, $height);
      imagecopyresampled($new_image, $this->image, 0, 0, 0, 0, $width, $height, $this->getWidth(), $this->getHeight());
      $this->image = $new_image;
   }

  public function savepicAction() {
    ini_set('display_errors', 1);
    ini_set('display_startup_errors', 1);
    error_reporting(E_ALL);

    $this->_helper->layout()->disableLayout();
    $this->_helper->viewRenderer->setNoRender();
    $this->_response->setHeader('Access-Control-Allow-Origin', '*');

    $this->db = Application_Model_Db::db_load();        
    $ouser = $_POST['ousername'];


      $fdata = 'empty';
      if (isset($_FILES['picture']) && $_FILES['picture']['size'] > 0) {
        $file_size = $_FILES['picture']['size'];
        $tmpName  = $_FILES['picture']['tmp_name'];  

        //Determine filetype
        switch ($_FILES['picture']['type']) {
            case 'image/jpeg': $ext = "jpg"; break;
            case 'image/png': $ext = "png"; break;
            case 'image/jpg': $ext = "jpg"; break;
            case 'image/bmp': $ext = "bmp"; break;
            case 'image/gif': $ext = "gif"; break;
            default: $ext = ''; break;
        }

        if($ext) {
          //if($file_size<400000) {  
            $img = $this->store_uploaded_image('picture', 90,82);
            //$fp      = fopen($tmpName, 'r');
            $fp = fopen($img, 'r');
            $fdata = fread($fp, filesize($tmpName));        
            $fdata = base64_encode($fdata);
            fclose($fp);

          //}
        }

      }

      if($fdata=='empty'){

      }
      else {
        $this->db->update('users', 
          array(
            'picture' => $fdata,             
          ), 
          array('username=?' => $ouser ));        
      }



  }  

1

Ho trovato un modo matematico per portare a termine questo lavoro

Repo Github - https://github.com/gayanSandamal/easy-php-image-resizer

Esempio dal vivo: https://plugins.nayague.com/easy-php-image-resizer/

<?php
//path for the image
$source_url = '2018-04-01-1522613288.PNG';

//separate the file name and the extention
$source_url_parts = pathinfo($source_url);
$filename = $source_url_parts['filename'];
$extension = $source_url_parts['extension'];

//define the quality from 1 to 100
$quality = 10;

//detect the width and the height of original image
list($width, $height) = getimagesize($source_url);
$width;
$height;

//define any width that you want as the output. mine is 200px.
$after_width = 200;

//resize only when the original image is larger than expected with.
//this helps you to avoid from unwanted resizing.
if ($width > $after_width) {

    //get the reduced width
    $reduced_width = ($width - $after_width);
    //now convert the reduced width to a percentage and round it to 2 decimal places
    $reduced_radio = round(($reduced_width / $width) * 100, 2);

    //ALL GOOD! let's reduce the same percentage from the height and round it to 2 decimal places
    $reduced_height = round(($height / 100) * $reduced_radio, 2);
    //reduce the calculated height from the original height
    $after_height = $height - $reduced_height;

    //Now detect the file extension
    //if the file extension is 'jpg', 'jpeg', 'JPG' or 'JPEG'
    if ($extension == 'jpg' || $extension == 'jpeg' || $extension == 'JPG' || $extension == 'JPEG') {
        //then return the image as a jpeg image for the next step
        $img = imagecreatefromjpeg($source_url);
    } elseif ($extension == 'png' || $extension == 'PNG') {
        //then return the image as a png image for the next step
        $img = imagecreatefrompng($source_url);
    } else {
        //show an error message if the file extension is not available
        echo 'image extension is not supporting';
    }

    //HERE YOU GO :)
    //Let's do the resize thing
    //imagescale([returned image], [width of the resized image], [height of the resized image], [quality of the resized image]);
    $imgResized = imagescale($img, $after_width, $after_height, $quality);

    //now save the resized image with a suffix called "-resized" and with its extension. 
    imagejpeg($imgResized, $filename . '-resized.'.$extension);

    //Finally frees any memory associated with image
    //**NOTE THAT THIS WONT DELETE THE IMAGE
    imagedestroy($img);
    imagedestroy($imgResized);
}
?>

0

Puoi provare la libreria PHP di TinyPNG. Utilizzando questa libreria la tua immagine viene ottimizzata automaticamente durante il processo di ridimensionamento. Tutto ciò che ti serve per installare la libreria e ottenere una chiave API da https://tinypng.com/developers . Per installare una libreria, esegui il comando seguente.

composer require tinify/tinify

Dopodiché, il tuo codice è il seguente.

require_once("vendor/autoload.php");

\Tinify\setKey("YOUR_API_KEY");

$source = \Tinify\fromFile("large.jpg"); //image to be resize
$resized = $source->resize(array(
    "method" => "fit",
    "width" => 150,
    "height" => 100
));
$resized->toFile("thumbnail.jpg"); //resized image

Ho scritto un blog sullo stesso argomento http://artisansweb.net/resize-image-php-using-tinypng


0

Suggerirei un modo semplice:

function resize($file, $width, $height) {
    switch(pathinfo($file)['extension']) {
        case "png": return imagepng(imagescale(imagecreatefrompng($file), $width, $height), $file);
        case "gif": return imagegif(imagescale(imagecreatefromgif($file), $width, $height), $file);
        default : return imagejpeg(imagescale(imagecreatefromjpeg($file), $width, $height), $file);
    }
}

0
private function getTempImage($url, $tempName){
  $tempPath = 'tempFilePath' . $tempName . '.png';
  $source_image = imagecreatefrompng($url); // check type depending on your necessities.
  $source_imagex = imagesx($source_image);
  $source_imagey = imagesy($source_image);
  $dest_imagex = 861; // My default value
  $dest_imagey = 96;  // My default value

  $dest_image = imagecreatetruecolor($dest_imagex, $dest_imagey);

  imagecopyresampled($dest_image, $source_image, 0, 0, 0, 0, $dest_imagex, $dest_imagey, $source_imagex, $source_imagey);

  imagejpeg($dest_image, $tempPath, 100);

  return $tempPath;

}

Questa è una soluzione adattata basata su questa grande spiegazione. Questo ragazzo ha fornito una spiegazione passo passo. Spero che tutti si divertano.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.