webentwicklung-frage-antwort-db.com.de

Bild skalieren mit PHP und Beibehalten des Seitenverhältnisses

Grundsätzlich möchte ich ein Bild hochladen (das ich sortiert habe) und es auf bestimmte Einschränkungen wie maximale Breite und Höhe skalieren, aber das Seitenverhältnis des Originalbildes beibehalten.

Ich habe Imagick nicht auf dem Server installiert - sonst wäre das einfach.

Jede Hilfe wird wie immer sehr geschätzt ... Danke.

EDIT: Ich brauche nicht den ganzen Code oder irgendetwas, nur ein Push in die richtige Richtung wäre fantastisch.

13
Steve_M

Ich hatte ein Stück Code so für ein anderes Projekt geschrieben, das ich gemacht habe. Ich habe es unten kopiert, vielleicht ein bisschen basteln! (Es erfordert die Gd-Bibliothek)

Dies sind die Parameter, die es benötigt:

$image_name - Name of the image which is uploaded
$new_width - Width of the resized photo (maximum)
$new_height - Height of the resized photo (maximum)
$uploadDir - Directory of the original image
$moveToDir - Directory to save the resized image

Ein Bild wird auf die maximale Breite oder Höhe verkleinert oder verkleinert

function createThumbnail($image_name,$new_width,$new_height,$uploadDir,$moveToDir)
{
    $path = $uploadDir . '/' . $image_name;

    $mime = getimagesize($path);

    if($mime['mime']=='image/png') { 
        $src_img = imagecreatefrompng($path);
    }
    if($mime['mime']=='image/jpg' || $mime['mime']=='image/jpeg' || $mime['mime']=='image/pjpeg') {
        $src_img = imagecreatefromjpeg($path);
    }   

    $old_x          =   imageSX($src_img);
    $old_y          =   imageSY($src_img);

    if($old_x > $old_y) 
    {
        $thumb_w    =   $new_width;
        $thumb_h    =   $old_y*($new_height/$old_x);
    }

    if($old_x < $old_y) 
    {
        $thumb_w    =   $old_x*($new_width/$old_y);
        $thumb_h    =   $new_height;
    }

    if($old_x == $old_y) 
    {
        $thumb_w    =   $new_width;
        $thumb_h    =   $new_height;
    }

    $dst_img        =   ImageCreateTrueColor($thumb_w,$thumb_h);

    imagecopyresampled($dst_img,$src_img,0,0,0,0,$thumb_w,$thumb_h,$old_x,$old_y); 


    // New save location
    $new_thumb_loc = $moveToDir . $image_name;

    if($mime['mime']=='image/png') {
        $result = imagepng($dst_img,$new_thumb_loc,8);
    }
    if($mime['mime']=='image/jpg' || $mime['mime']=='image/jpeg' || $mime['mime']=='image/pjpeg') {
        $result = imagejpeg($dst_img,$new_thumb_loc,80);
    }

    imagedestroy($dst_img); 
    imagedestroy($src_img);

    return $result;
}
11
Phil Cross

Eigentlich ist die akzeptierte Lösung nicht die richtige Lösung. Der Grund ist einfach: Es kann Fälle geben, in denen das Verhältnis des Quellbildes und das Verhältnis des Zielbildes unterschiedlich sind. Jede Berechnung sollte diesen Unterschied widerspiegeln.

Bitte beachten Sie die entsprechenden Zeilen aus dem Beispiel auf der PHP.net-Website:

$ratio_orig = $width_orig/$height_orig;

if ($width/$height > $ratio_orig) {
   $width = $height*$ratio_orig;
} else {
   $height = $width/$ratio_orig;
}

Das vollständige Beispiel finden Sie hier: http://php.net/manual/de/function.imagecopyresampled.php

Es gibt andere Antworten (mit Beispielen) zu stackoverflow auf ähnliche Fragen (dieselbe Frage, die auf eine andere Art formuliert wurde), die das gleiche Problem haben.

Beispiel:

Nehmen wir an, wir haben ein Bild mit 1630 x 2400 Pixeln, dessen Größe automatisch geändert werden soll, wobei das Seitenverhältnis auf 160 x 240 eingestellt wird. Lassen Sie uns ein wenig rechnen, um die akzeptierte Lösung zu finden:

if($old_x < $old_y) 
    {
        $thumb_w    =   $old_x*($new_width/$old_y);
        $thumb_h    =   $new_height;
    }

height = 240 width = 1630 * (160/2400) = 1630 * 0.0666666666666667 = 108.6666666666667 108.6 x 240 ist nicht die richtige Lösung.

Die nächste vorgeschlagene Lösung ist folgende:

if($old_x < $old_y)
    {
        $thumb_w    =   $old_x/$old_y*$newHeight;
        $thumb_h    =   $newHeight;
    }

height = 240; width = 1630/2400 * 240 = 163 Es ist besser (da das Seitenverhältnis beibehalten wird), aber die maximal akzeptierte Breite wurde überschritten.

Beide scheitern.

Wir rechnen nach der von PHP.net vorgeschlagenen Lösung: __.width = 160 Height = 160/(1630/2400) = 160/0.6791666666666667 = 235.5828220858896 (die Klausel else). 160 x 236 (gerundet) ist die richtige Antwort.

17
Florin Sima

Formule ist falsch, um das Seitenverhältnis einzuhalten . Es sollte lauten: Originalhöhe/Originalbreite x neue Breite = neue Höhe

function createThumbnail($imageName,$newWidth,$newHeight,$uploadDir,$moveToDir)
{
    $path = $uploadDir . '/' . $imageName;

    $mime = getimagesize($path);

    if($mime['mime']=='image/png'){ $src_img = imagecreatefrompng($path); }
    if($mime['mime']=='image/jpg'){ $src_img = imagecreatefromjpeg($path); }
    if($mime['mime']=='image/jpeg'){ $src_img = imagecreatefromjpeg($path); }
    if($mime['mime']=='image/pjpeg'){ $src_img = imagecreatefromjpeg($path); }

    $old_x = imageSX($src_img);
    $old_y = imageSY($src_img);

    if($old_x > $old_y)
    {
        $thumb_w    =   $newWidth;
        $thumb_h    =   $old_y/$old_x*$newWidth;
    }

    if($old_x < $old_y)
    {
        $thumb_w    =   $old_x/$old_y*$newHeight;
        $thumb_h    =   $newHeight;
    }

    if($old_x == $old_y)
    {
        $thumb_w    =   $newWidth;
        $thumb_h    =   $newHeight;
    }

    $dst_img        =   ImageCreateTrueColor($thumb_w,$thumb_h);

    imagecopyresampled($dst_img,$src_img,0,0,0,0,$thumb_w,$thumb_h,$old_x,$old_y);


    // New save location
    $new_thumb_loc = $moveToDir . $imageName;

    if($mime['mime']=='image/png'){ $result = imagepng($dst_img,$new_thumb_loc,8); }
    if($mime['mime']=='image/jpg'){ $result = imagejpeg($dst_img,$new_thumb_loc,80); }
    if($mime['mime']=='image/jpeg'){ $result = imagejpeg($dst_img,$new_thumb_loc,80); }
    if($mime['mime']=='image/pjpeg'){ $result = imagejpeg($dst_img,$new_thumb_loc,80); }

    imagedestroy($dst_img);
    imagedestroy($src_img);
    return $result;
}
3
user2809327

Ich habe darüber nachgedacht, wie ich das erreichen kann, und ich kam mit einer hübschen Nizza-Lösung, die auf jeden Fall funktioniert ....__ Nehmen wir an, Sie möchten die Größe der Bilder ändern, die Benutzer auf Ihre Website hochladen, aber Sie brauchen es, um das Verhältnis zu erhalten. So kam ich dazu:

<?php
// File 
$filename = 'test.jpg';



// Get sizes
list($width, $height) = getimagesize($filename);
//obtain ratio
$imageratio = $width/$height;

if($imageratio >= 1){
    $newwidth = 600;
    $newheight = 600 / $imageratio; 
}
else{
     $newidth = 400;
     $newheight = 400 / $imageratio;
};




// Load
$thumb = imagecreatetruecolor($newwidth, $newheight);
$source = imagecreatefromjpeg($filename);

// Resize
imagecopyresized($thumb, $source, 0, 0, 0, 0, $newwidth, $newheight, $width, 
$height);

// Output
imagejpeg($thumb, "img/test.jpg");
imagedestroy();
?>

In diesem Fall wollte ich, wenn die Breite größer als die Höhe ist, 600px und wenn die Höhe größer als die Breite war, wollte ich die Breite 400px 

1
Pit B. Groove

Ich habe einen mathematischen Weg gefunden, um diese Arbeit zu erledigen

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

Live-Beispiel - 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
Gayan Sandamal
<?php
Class ResizedImage
{
    public $imgfile;
    public $string      = '';
    public $new_width   = 0;
    public $new_height  = 0;
    public $angle       = 0;
    public $max_font_size = 1000;
    public $cropped = false;//whether crop the original image if h or w > new h or w
    public $font = 'fonts/arialbd.ttf';

    private $img;
    private $trans_colour;
    private $orange;
    private $white; 
    private $whitetr;
    private $blacktr;

    public function PrintAsBase64()
    {
        $this->SetImage();
        ob_start();
        imagepng($this->img);
        $b64img = ob_get_contents();
        ob_clean();
        imagedestroy($this->img);
        $b64img = base64_encode($b64img);
        echo($b64img);
    }
    public function PrintAsImage()
    {
        $this->SetImage();

        header('Content-type: image/png');

        imagepng($this->img);
        imagedestroy($this->img);
    }

    private function SetImage()
    {
        if ($this->imgfile == '') {$this->imgfile='NoImageAvailable.jpg';}
        $this->img          = imagecreatefromstring(file_get_contents($this->imgfile));
        $this->trans_colour = imagecolorallocatealpha($this->img, 0, 0, 0, 127);
        $this->orange       = imagecolorallocate($this->img, 220, 210, 60);
        $this->white        = imagecolorallocate($this->img, 255,255, 255);
        $this->whitetr      = imagecolorallocatealpha($this->img, 255,255, 255, 95);
        $this->blacktr      = imagecolorallocatealpha($this->img, 0, 0, 0, 95);

        if ((!$this->cropped) && ($this->string !=''))
        {$this->watermarkimage();}

        if (($this->new_height > 0) && ($this->new_width > 0)) {$this->ResizeImage();};

        if (($this->cropped) && ($this->string !=''))
        {$this->watermarkimage();}

        imageAlphaBlending($this->img, true);
        imageSaveAlpha($this->img, true);
    }
    ////
    private function ResizeImage()
    {
        # v_fact and h_fact are the factor by which the original vertical / horizontal
        # image sizes should be multiplied to get the image to your target size.
        $v_fact = $this->new_height / imagesy($this->img);//target_height / im_height; 
        $h_fact = $this->new_width / imagesx($this->img);//target_width / im_width;
        # you want to resize the image by the same factor in both vertical 
        # and horizontal direction, so you need to pick the correct factor from
        # v_fact / h_fact so that the largest (relative to target) of the new height/width
        # equals the target height/width and the smallest is lower than the target.
        # this is the lowest of the two factors
        if($this->cropped) 
        {   $im_fact = max($v_fact, $h_fact);   }
        else
        {   $im_fact = min($v_fact, $h_fact);   }

        $new_height = round(imagesy($this->img) * $im_fact);
        $new_width  = round(imagesx($this->img) * $im_fact);

        $img2 = $this->img;     
        $this->img = imagecreatetruecolor($new_width, $new_height);     
        imagecopyresampled($this->img, $img2, 0, 0, 0, 0, $new_width, $new_height, imagesx($img2), imagesy($img2));

        $img2 = $this->img;     
        $this->img = imagecreatetruecolor($this->new_width, $this->new_height);
        imagefill($this->img, 0, 0, $this->trans_colour);

        $dstx = 0;
        $dsty = 0;
        if ($this->cropped)
        {
            if (imagesx($this->img) < imagesx($img2))
            {   $dstx = round((imagesx($this->img)-imagesx($img2))/2); }

            if (imagesy($this->img) < imagesy($img2))
            {   $dsty = round((imagesy($this->img)-imagesy($img2))/2); }
        }
        else
        {
            if (imagesx($this->img) > imagesx($img2))
            {   $dstx = round((imagesx($this->img)-imagesx($img2))/2); }

            if (imagesy($this->img) > imagesy($img2))
            {   $dsty = round((imagesy($this->img)-imagesy($img2))/2); }
        }

        imagecopy ( $this->img, $img2, $dstx, $dsty, 0, 0, imagesx($img2) , imagesy($img2));
        imagedestroy($img2);        
    }   

    ////

    private function calculateTextBox($text,$fontFile,$fontSize,$fontAngle) 
    { 
        /************ 
        simple function that calculates the *exact* bounding box (single pixel precision). 
        The function returns an associative array with these keys: 
        left, top:  coordinates you will pass to imagettftext 
        width, height: dimension of the image you have to create 
        *************/ 
        $rect = imagettfbbox($fontSize,$fontAngle,$fontFile,$text); 
        $minX = min(array($rect[0],$rect[2],$rect[4],$rect[6])); 
        $maxX = max(array($rect[0],$rect[2],$rect[4],$rect[6])); 
        $minY = min(array($rect[1],$rect[3],$rect[5],$rect[7])); 
        $maxY = max(array($rect[1],$rect[3],$rect[5],$rect[7])); 

        return array( 
        "left"   => abs($minX) - 1, 
        "top"    => abs($minY) - 1, 
        "width"  => $maxX - $minX, 
        "height" => $maxY - $minY,
        "box"    => $rect ); 
    }

    private function watermarkimage($font_size=0)
    {
        if ($this->string == '')
        {die('Watermark function call width empty string!');}

        $box = $this->calculateTextBox($this->string, $this->font, $font_size, $this->angle);
        while ( ($box['width'] < imagesx($this->img)) && ($box['height'] < imagesy($this->img)) && ($font_size <= $this->max_font_size) )
        {
            $font_size++;
            $box = $this->calculateTextBox($this->string, $this->font, $font_size, $this->angle);   
        }

        $font_size--;
        $box = $this->calculateTextBox($this->string, $this->font, $font_size, $this->angle);

        $vcenter = round((imagesy($this->img) / 2) + ($box['height'] / 2));  
        $hcenter = round((imagesx($this->img) - $box['width']) / 2 );

        imagettftext($this->img, $font_size, $this->angle, $hcenter, $vcenter, $this->blacktr, $this->font, $this->string);     
        imagettftext($this->img, $font_size, $this->angle, $hcenter+1, $vcenter-2, $this->whitetr, $this->font, $this->string);
    }
}
?>

Ich habe auch die akzeptierte Antwort verwendet, aber das Verhältnis wird in einigen Fällen nicht beibehalten. Ich habe im Forum einige gute Antworten gefunden, habe sie zusammengefügt und schließlich eine Klasse erstellt, die die Größe eines Bildes ändert. Als zusätzliche Funktion können Sie einen Wasserzeichen-Text einfügen.

sie können sehen, was passiert, wenn Sie beschneiden möchten oder nicht. Andernfalls wird dem neuen Bild ein transparenter Bereich hinzugefügt.

Dieses Beispiel ist mehr als gefragt, aber ich denke, es ist ein gutes Beispiel.

0
coban

Dies ist meine Funktion zum Skalieren eines Bildes mit einem sicheren Seitenverhältnis für X, Y oder beide Achsen.

Es skaliert auch ein Bild für einen Prozentsatz seiner Größe.

Kompatibel mit PHP 5.4

/** Use X axis to scale image. */
define('IMAGES_SCALE_AXIS_X', 1);
/** Use Y axis to scale image. */
define('IMAGES_SCALE_AXIS_Y', 2);
/** Use both X and Y axes to calc image scale. */
define('IMAGES_SCALE_AXIS_BOTH', IMAGES_SCALE_AXIS_X ^ IMAGES_SCALE_AXIS_Y);
/** Compression rate for JPEG image format. */
define('JPEG_COMPRESSION_QUALITY', 90);
/** Compression rate for PNG image format. */
define('PNG_COMPRESSION_QUALITY', 9);

/**
 * Scales an image with save aspect ration for X, Y or both axes.
 *
 * @param string $sourceFile Absolute path to source image.
 * @param string $destinationFile Absolute path to scaled image.
 * @param int|null $toWidth Maximum `width` of scaled image.
 * @param int|null $toHeight Maximum `height` of scaled image.
 * @param int|null $percent Percent of scale of the source image's size.
 * @param int $scaleAxis Determines how of axis will be used to scale image.
 *
 * May take a value of {@link IMAGES_SCALE_AXIS_X}, {@link IMAGES_SCALE_AXIS_Y} or {@link IMAGES_SCALE_AXIS_BOTH}.
 * @return bool True on success or False on failure.
 */
function scaleImage($sourceFile, $destinationFile, $toWidth = null, $toHeight = null, $percent = null, $scaleAxis = IMAGES_SCALE_AXIS_BOTH) {
    $toWidth = (int)$toWidth;
    $toHeight = (int)$toHeight;
    $percent = (int)$percent;
    $result = false;

    if (($toWidth | $toHeight | $percent)
        && file_exists($sourceFile)
        && (file_exists(dirname($destinationFile)) || mkdir(dirname($destinationFile), 0777, true))) {

        $mime = getimagesize($sourceFile);

        if (in_array($mime['mime'], ['image/jpg', 'image/jpeg', 'image/pjpeg'])) {
            $src_img = imagecreatefromjpeg($sourceFile);
        } elseif ($mime['mime'] == 'image/png') {
            $src_img = imagecreatefrompng($sourceFile);
        }

        $original_width = imagesx($src_img);
        $original_height = imagesy($src_img);

        if ($scaleAxis == IMAGES_SCALE_AXIS_BOTH) {
            if (!($toWidth | $percent)) {
                $scaleAxis = IMAGES_SCALE_AXIS_Y;
            } elseif (!($toHeight | $percent)) {
                $scaleAxis = IMAGES_SCALE_AXIS_X;
            }
        }

        if ($scaleAxis == IMAGES_SCALE_AXIS_X && $toWidth) {
            $scale_ratio = $original_width / $toWidth;
        } elseif ($scaleAxis == IMAGES_SCALE_AXIS_Y && $toHeight) {
            $scale_ratio = $original_height / $toHeight;
        } elseif ($percent) {
            $scale_ratio = 100 / $percent;
        } else {
            $scale_ratio_width = $original_width / $toWidth;
            $scale_ratio_height = $original_height / $toHeight;

            if ($original_width / $scale_ratio_width < $toWidth && $original_height / $scale_ratio_height < $toHeight) {
                $scale_ratio = min($scale_ratio_width, $scale_ratio_height);
            } else {
                $scale_ratio = max($scale_ratio_width, $scale_ratio_height);
            }
        }

        $scale_width = $original_width / $scale_ratio;
        $scale_height = $original_height / $scale_ratio;

        $dst_img = imagecreatetruecolor($scale_width, $scale_height);

        imagecopyresampled($dst_img, $src_img, 0, 0, 0, 0, $scale_width, $scale_height, $original_width, $original_height);

        if (in_array($mime['mime'], ['image/jpg', 'image/jpeg', 'image/pjpeg'])) {
            $result = imagejpeg($dst_img, $destinationFile, JPEG_COMPRESSION_QUALITY);
        } elseif ($mime['mime'] == 'image/png') {
            $result = imagepng($dst_img, $destinationFile, PNG_COMPRESSION_QUALITY);
        }

        imagedestroy($dst_img);
        imagedestroy($src_img);
    }

    return $result;
}

Tests:

$sourceFile = '/source/file.jpg'; // Original size: 672x100
$destinationPath = '/destination/path/';

scaleImage($sourceFile, $destinationPath . 'file_original_size.jpg', 672, 100);
// Result: Image 672x100
scaleImage($sourceFile, $destinationPath . 'file_scaled_75_PERCENT.jpg', null, null, 75);
// Result: Image 504x75
scaleImage($sourceFile, $destinationPath . 'file_scaled_336_X.jpg', 336, null, null, IMAGES_SCALE_AXIS_X);
// Result: Image 336x50
scaleImage($sourceFile, $destinationPath . 'file_scaled_50_Y.jpg', null, 50, null, IMAGES_SCALE_AXIS_Y);
// Result: Image 336x50
scaleImage($sourceFile, $destinationPath . 'file_scaled_500x70_BOTH.jpg', 500, 70, null, IMAGES_SCALE_AXIS_BOTH);
// Result: Image 470x70
scaleImage($sourceFile, $destinationPath . 'file_scaled_450x70_BOTH.jpg', 450, 70, null, IMAGES_SCALE_AXIS_BOTH);
// Result: Image 450x66
scaleImage($sourceFile, $destinationPath . 'file_scaled_500x70_40_PERCENT_BOTH.jpg', 500, 70, 40, IMAGES_SCALE_AXIS_BOTH);
// Result: Image 268x40
0
GHosT

Ich weiß, dass Sie nach einem Teiler suchen, der es erlaubt, Ihr Bild proportional zu skalieren. Überprüfen Sie diese Demo

Wie man unseren Teiler mathematisch erhält

nehmen wir an, unser Originalbild hat die Breite x und die Höhe y; x = 300 und y = 700

Maximale Höhe und maximale Breite beträgt 200;

Zuerst prüfen wir, welche Dimension des Bildes größer ist als die andere. Unsere Höhe (y) ist größer als Breite (x) 

Zweitens prüfen wir, ob unsere Höhe größer ist als unsere maximale Höhe ..__ In unserem Fall ist unsere Höhe größer als die maximale Höhe. In einem Fall, in dem die maximale Höhe unterschritten wird, setzen wir unsere neue Höhe auf unsere ursprüngliche Höhe.

Schließlich suchen wir unseren Divisor wie unten gezeigt

if y is set to maximum height 200 and max-y=200;
y=max-y, that is 
if y=max-y
what about 
x=?
that is, 
if 700 is resized to 200
what about 300?
700=200
300=?
new width = (200 (new height) * 300(width)) / 700 (height)
so our divisor is
divisor= new height (300) / height(700) 
new width = divisor * width or width / (1/divisor)

und umgekehrt für die Breite, wenn diese größer als die Höhe ist

if ($width > $height) {
    if($width < $max_width)
        $newwidth = $width;

    else

    $newwidth = $max_width; 


    $divisor = $width / $newwidth;
    $newheight = floor( $height / $divisor);
}
else {

     if($height < $max_height)
         $newheight = $height;
     else
         $newheight =  $max_height;

    $divisor = $height / $newheight;
    $newwidth = floor( $width / $divisor );
}

Sehen Sie sich das vollständige Beispiel an und probieren Sie es mit der Arbeitsdemo .

0
Daniel Nyamasyo

funktioniert perfekt für mich

    static function getThumpnail($file){

    $THUMBNAIL_IMAGE_MAX_WIDTH  = 150; # exmpl.
    $THUMBNAIL_IMAGE_MAX_HEIGHT = 150;

    $src_size = filesize($file);
    $filename = basename($file);

    list($src_width, $src_height, $src_type) = getimagesize($file);
    $src_im = false;
    switch ($src_type) {
        case IMAGETYPE_GIF  : $src_im = imageCreateFromGif($file);  break;
        case IMAGETYPE_JPEG : $src_im = imageCreateFromJpeg($file); break;
        case IMAGETYPE_PNG  : $src_im = imageCreateFromPng($file);  break;
        case IMAGETYPE_WBMP  : $src_im = imagecreatefromwbmp($file);  break;
    }   
    if ($src_im === false) { return false; }

    $src_aspect_ratio = $src_width / $src_height;
    $thu_aspect_ratio = $THUMBNAIL_IMAGE_MAX_WIDTH / $THUMBNAIL_IMAGE_MAX_HEIGHT;

    if ($src_width <= $THUMBNAIL_IMAGE_MAX_WIDTH && $src_height <= $THUMBNAIL_IMAGE_MAX_HEIGHT) {
        $thu_width  = $src_width;
        $thu_height = $src_height;
    } elseif ($thu_aspect_ratio > $src_aspect_ratio) {
        $thu_width  = (int) ($THUMBNAIL_IMAGE_MAX_HEIGHT * $src_aspect_ratio);
        $thu_height = $THUMBNAIL_IMAGE_MAX_HEIGHT;
    } else {
        $thu_width = $THUMBNAIL_IMAGE_MAX_WIDTH;
        $thu_height = (int) ($THUMBNAIL_IMAGE_MAX_WIDTH / $src_aspect_ratio);
    }

    $thu_im = imagecreatetruecolor($thu_width, $thu_height);
    imagecopyresampled($thu_im, $src_im, 0, 0, 0, 0, $thu_width, $thu_height, $src_width, $src_height);

    $dst_im    = imagecreatetruecolor($THUMBNAIL_IMAGE_MAX_WIDTH,$THUMBNAIL_IMAGE_MAX_WIDTH);
    $backcolor = imagecolorallocate($dst_im,192,192,192);
    imagefill($dst_im,0,0,$backcolor);
    imagecopy($dst_im, $thu_im, (imagesx($dst_im)/2)-(imagesx($thu_im)/2), (imagesy($dst_im)/2)-(imagesy($thu_im)/2), 0, 0, imagesx($thu_im), imagesy($thu_im));
    imagedestroy($src_im);
    imagedestroy($thu_im);
    }
0
gungott