[PHP] Bild bei Upload verkleinern

Dieses Thema im Forum "Webentwicklung" wurde erstellt von L33do, 21. Mai 2008 .

  1. 21. Mai 2008
    Bild bei Upload verkleinern

    Hey,

    ich habe mit dem Script nun geschafft, ein Bild auf den Webspace zu transportieren:

    Code:
    <?php $uploaddir = 'upload/';
    
    print "<pre>";
    if (move_uploaded_file($_FILES['userfile']['tmp_name'], $uploaddir . $_FILES['userfile']['name'])) {
     echo "Erfolgreich hochgeladen!";
    } else { 
    } ?>
    Nun würde ich jedoch gerne direkt beim Upload das Bild auch verkleinern lassen auf eine bestimme Breite, nur wie stelle ich das an bzw. binde das passend ein?

    Mit freundlichen Grüßen,
    L33do
     
  2. 21. Mai 2008
    AW: Bild bei Upload verkleinern

    Erstmal würde ich dir empfehlen die Dateien die hochgeladen werden auf jeden Fall zu filtern!
    Sonst wird dein Projekt (vermutlich, je nach Einsatz des Scriptes) nicht lange leben .

    Zum Thema vergrößern/verkleinern, solltest du dir das mal ansehen : http://www.4wordsystems.com/php_image_resize.php

    zudem : PHP: GD - Manual
     
  3. 22. Mai 2008
    AW: Bild bei Upload verkleinern

    Vielen Dank, funktioniert einwandfrei!

    Bez. des Filterns: Was genau hat das für einen Nutzen für mich bzw. wie wende ich das an?

    Mit freundlichen Grüßen,
    L33do
     
  4. 22. Mai 2008
    AW: Bild bei Upload verkleinern

    Nunja, momentan kann ja jede Datei hochgeladen werden, also nicht nur Bilder , sprich es wäre möglich PHP / ScriptDateien Hochzulagen und auszuführen, die Folgen davon kannst du dir ja sicher ausmalen.

    Zur Filterung gibt es 100e von Ansätzen ein relativ einfacher und guter Ansatz/Möglichkeit ist die Überprüfung des hochgeladenen "Bildes" per getimagesize();.
    Die Funktion gibt bei Bildern die Größe/Ausmaße etc. an , bei einem "nicht Bild" -> PHP z.B. gibt sie "NULL" aus.

    Ein Beispiel könnte so aussehen :

    PHP:
    <? php 
    $uploaddir 
    'upload/' ;
    print 
    "<pre>" ;
    if (
    move_uploaded_file ( $_FILES [ 'userfile' ][ 'tmp_name' ],  $uploaddir  $_FILES [ 'userfile' ][ 'name' ])) {
        echo 
    "Erfolgreich hochgeladen!" ;
    } else { 

    $size  getimagesize ( $uploaddir  $_FILES [ 'userfile' ][ 'name' ]));
    if (
    $size  ==  NULL ) {  unlink ( $uploaddir  $_FILES [ 'userfile' ][ 'name' ])); }

    // Nicht getestet

    ?>
    Eine andere (möglicherweise bessere) Methode stellen die MIME Typen dar, aber am einfachsten Googelst du "sicherem Dateiupload PHP" oder ähnlichem und schaust dir die Möglichkeiten an.
     
  5. 22. Mai 2008
    AW: Bild bei Upload verkleinern

    hab ne klasse die genau das macht.
    Spoiler
    PHP:
    <? php
        
    class  mcImage  {
            public 
    $width  false $height  false ;
            const 
    PNG  1 JPEG  2 GIF  3 BMP  4 ;
            protected 
    $imageLink $type  false ;
            protected 
    $newImageContent $newImageLink ;
            
            public function 
    __construct ( $type  false ) {
                
    $this -> setType ( $type );
            }
            
            public function 
    setTypeByExt ( $ext ) {
                switch(
    strtolower ( $ext )) {
                    case 
    'png' :
                        
    $this -> type  self :: PNG ;
                        break;
                    case 
    'jpg' :
                    case 
    'jpeg' :
                        
    $this -> type  self :: JPEG ;
                        break;
                    case 
    'gif' :
                        
    $this -> type  self :: GIF ;
                        break;
                    default: 
    $this -> type  self :: BMP ;
                }
            }
            
            public function 
    setType ( $type ) {
                if(
    $type  !==  false ) {
                    switch(
    $type ) {
                        case 
    self :: PNG :
                        case 
    self :: JPEG :
                        case 
    self :: GIF :
                            
    $this -> type  $type ;
                            break;
                        default: 
    $this -> type  self :: BMP ;
                    }
                }
            }
            
            public function 
    width () { return  imageSX ( $this -> imageLink ); }
            public function 
    height () { return  imageSY ( $this -> imageLink ); }
            
            public function 
    scaleHeight ( $width ) {
                
    $imageHeight  imageSY ( $this -> imageLink );
                
    $imageWidth  imageSX ( $this -> imageLink );
                
                if(
    $imageWidth  $width ) {
                    
    $pWidth  $width  $imageWidth ;
                    return 
    round ( $imageHeight  $pWidth );
                }
                
                return 
    $imageHeight ;
            }
            
            public function 
    createFrom ( $path $ext ) {
                switch(
    mcString :: toLowerCase ( $ext )) {
                    case 
    'png' :
                        
    $this -> imageLink  imageCreateFromPNG ( $path );
                        break;
                    case 
    'jpg' :
                    case 
    'jpeg' :
                        
    $this -> imageLink  imageCreateFromJPEG ( $path );
                        break;
                    case 
    'gif' :
                        
    $this -> imageLink  imageCreateFromGIF ( $path );
                        break;
                    case 
    'bmp' :
                        
    $this -> imageLink  imageCreateFromWBMP ( $path );
                        break;
                    default: 
    trigger_error ( 'unknown image-extension "'  $ext  '"' E_USER_ERROR );
                }
            }
            
            public function 
    create () {
                if(
    $this -> type  ===  false ) {
                    throw new 
    Exception ( 'no image type set!' );
                }
                
                
    //check width & height
                
    $width  = ((! $this -> width ) ?  imageSX ( $this -> imageLink ) :  $this -> width );
                
    $height  = ((! $this -> height ) ?  imageSY ( $this -> imageLink ) :  $this -> height );
                
                
    $link  imageCreateTRUEColor ( $width $height );
                
                
    //copy
                
    imageCopyResampled (
                    
    $link ,
                    
    $this -> imageLink ,
                    
    0 0 0 0 ,
                    
    $width $height ,
                    
    imageSX ( $this -> imageLink ),
                    
    imageSY ( $this -> imageLink )
                );
                
                
    ob_start ();
                switch(
    $this -> type ) {
                    case 
    self :: PNG :
                        
    imagePNG ( $link );
                        break;
                    case 
    self :: JPEG :
                        
    imageJPEG ( $link );
                        break;
                    case 
    self :: GIF :
                        
    imageGIF ( $link );
                        break;
                    case 
    self :: BMP :
                        
    imageWBMP ( $link );
                        break;
                    default: 
    trigger_error ( 'error, unknown image-type set. you have to call "createFrom" first!' E_USER_ERROR );
                }
                
                
    $this -> newImageContent  ob_get_clean ();
                
    $this -> newImageLink  $link ;
            }
            
            public function 
    getNewImage () {
                return 
    $this -> newImageLink ;
            }
            
            public function 
    getNewImageBin () {
                return 
    $this -> newImageContent ;
            }
            
            public function 
    getImage () {
                return 
    $this -> imageLink ;
            }
            
            public function 
    destroy () {
                
    imageDestroy ( $this -> imageLink );
                
    imageDestroy ( $this -> newImageLink );
            }
        }
    ?>

    PHP:
    <? php
        $image 
    = new  mcImage ( mcImage :: PNG );
        
    $image -> createFrom ( 'link/zum/bild.jpg' 'jpeg' );
        
    $image -> width  200 ;
        
    $image -> height  $image -> scaleHeight ( 200 );
        
    $image -> create ();
        
    $image -> destroy ();
        
        
    header ( 'content-type:image/png' );
        print 
    $image -> getNewImageBin ();
    ?>
    wegen sicherheit:
    PHP:
    <? php
        
    //maximale größe der datein
        
    $maxFileSize  1024 //byte
        
        //erlaubte datei-typen
        
    $allowedFileTypes  = array(
            
    'text/plain' ,
            
    'text/html' ,
            
    'text/xml'
        
    );
        
        
    //upload speichern unter
        
    $uploadSaveIn  './uploads/' //das / am ende ned vergessen
        
        //upload?
        
    if(isset( $_FILES [ 'upload' ])) {
            
    //test ob datei sich im tmp-ornder befindet und wirklich hochgeladen wurde
            
    if(! is_uploaded_file ( $_FILES [ 'upload' ][ 'tmp_name' ]))
                exit(
    'invalider upload' );
            
            
    //schaun wir uns mal die größe an
            
    if(! $_FILES [ 'upload' ][ 'size' ])  //leer
                
    exit( 'datei is leer, wer braucht sowas?' );
            elseif(
    $_FILES [ 'upload' ][ 'size' ] >  $maxFileSize //zu groß
                
    exit( 'datei ist zu groß, maximal erlaubt sind: '  $maxFileSize  .
                    
    '(bytes) - '  . ( round ( $maxFileSize  1024 )) .  ' (kb)' );
            
            
    //mime erlaubt?
            
    if(! in_array ( $_FILES [ 'upload' ][ 'type' ],  $allowedFileTypes ))
                exit(
    'datei-typ "'  $_FILES [ 'upload' ][ 'type' ] .  '" nicht erlaubt' );
                
            
    //naja große passt, mime ist in orndung und datei is ein valider upload
            
    $filePath  $uploadSaveIn  $_FILES [ 'upload' ][ 'name' ];
            if(!@
    move_uploaded_file ( $_FILES [ 'upload' ][ 'tmp_name' ],  $filePath ))
                exit(
    'upload fehlgeschlagen. datei konnte nicht verschoben werden.' );
                
            
    //okay, schaun wir mal obs ein bild ist
            
    $image  false ;
            switch(
    $_FILES [ 'upload' ][ 'type' ]) {
                case 
    'image/png' :
                    
    $image  'png' ;
                    break;
                case 
    'image/jpg' :
                case 
    'image/jpeg' :
                    
    $image  'jpeg' ;
                    break;
                case 
    'image/gif' :
                    
    $image  'gif' ;
                    break;
                case 
    'image/bmp' :
                    
    $image  'bmp' ;
                    break;
            }
            
            if(
    $image  !==  false ) {
                
    //hier kannst du das bild in $filePath verkleinern
            
    }
            
            
    //link ausgeben usw solltest du ja können.
            
    exit( 'upload erfolgreich' );
        }
    ?>
     
  6. Video Script

    Videos zum Themenbereich

    * gefundene Videos auf YouTube, anhand der Überschrift.