Edit Report a Bug

    getimagesize

    (PHP 4, PHP 5, PHP 7, PHP 8)

    getimagesize — Retourne la taille d'une image

    Description

    getimagesize(string $filename, array &$image_info = null): array|false

    getimagesize() détermine la taille de toute image supportée fournie et en retourne les dimensions, le type d'image et une chaîne type height/width à placer dans une balise HTML IMG normale et le type de contenu HTTP correspondant.

    getimagesize() peut également retourner plus d'informations dans le paramètre image_info.

    Attention

    Cette fonction s'attend à ce que filename soit un fichier image valide. Si un fichier non image est fourni, il peut être détecté de manière incorrecte en tant qu'image et la fonction retournera avec succès, mais le tableau peut contenir des valeurs absurdes.

    N'utilisez pas getimagesize() pour vérifier qu'un fichier donné est une image valide. Utilisez à la place une solution prévue pour cela telle que l'extension FileInfo.

    Note: Notez que JPC et JP2 sont capables d'avoir des composants avec une profondeur de bit différente. Dans ce cas, la valeur de "bits" est la plus grande profondeur de bit rencontrée. De même, les fichiers JP2 disposent du support de multiple JPEG 2000 codestreams. Dans ce cas, getimagesize() retourne les valeurs pour le premier codestream rencontré à la racine du fichier.

    Note: Les informations sur les icônes sont récupérées depuis l'icône possédant le plus haut débit.

    Note: Les images GIF consistant d'un ou plusieurs cadres, où chaque cadre peut occuper uniquement une partie de l'image. La taille de l'image qui est rapportée par getimagesize() est la taille globale (lu depuis le descripteur logique de l'écran).

    Liste de paramètres

    filename

    Ce paramètre spécifie le fichier dont vous voulez récupérer les informations. Il peut être un fichier local ou (suivant la configuration), un fichier distant en utilisant un des flux supportés.

    image_info

    Ce paramètre optionnel permet d'extraire des informations supplémentaires du fichier image. Actuellement, cette option va retourner différents marqueurs JPG APP dans un tableau associatif. Certains programmes utilisent ces marqueur APP pour préciser les informations dans les balises HTML. Un marqueur commun est le marqueur APP13, décrit à » IPTC. Vous pouvez utiliser la fonction iptcparse() pour analyser ce marqueur, et obtenir des informations intelligibles.

    Note:

    image_info supporte uniquement les fichiers JFIF.

    Valeurs de retour

    Retourne un tableau contenant jusqu'à 7 éléments. Tous les types d'images n'incluent pas les éléments channels et bits.

    L'index 0 contient la largeur. L'index 1 contient la hauteur.

    Note:

    Certains formats peuvent ne contenir aucune image, ou bien plusieurs. Dans ces cas-là, getimagesize() peut ne pas être capable de déterminer correctement la taille de l'image. getimagesize() retourne alors zéro comme taille de hauteur et largeur.

    L'index 2 est une constante parmi IMAGETYPE_XXX constants, indiquant le type de l'image.

    L'index 3 contient la chaîne à placer dans les balises IMG : height="xxx" width="yyy".

    mime correspond au type MIME d'une image. Cette information peut être utilisée pour envoyer l'en-tête HTTP Content-type correct :

    Exemple #1 getimagesize() et types MIME

    <?php
    $size     = getimagesize($filename);
    $fp = fopen($filename, "rb");
    if (    $size && $fp) {
    header("Content-type: {$size['mime']}");
    fpassthru($fp);
    exit;
    } else {
    // error
    }
    ?>

    channels sera 3 pour des images RGB et 4 pour des images CMYK.

    bits est le nombre d'octets pour chaque couleur.

    Cependant, la présence des valeurs de channels et de bits peut mener à la confusion. Par exemple, une image GIF utilise toujours trois canaux par pixel, mais le nombre de bits par pixel ne peut être calculé dans le cas d'une image animée GIF ayant une table de couleur globale.

    Si une erreur survient, false est retourné.

    Erreurs / Exceptions

    Si l'accès à filename est impossible, getimagesize() générera une erreur de niveau E_WARNING. Si une erreur survient lors de la lecture, getimagesize() générera une erreur de niveau E_NOTICE.

    Historique

    Version Description
    8.2.0 Retourne les dimensions actuelles de l'image, bits et chaînes des images AVIF; précédemment, les dimensions étaient reportées en tant que 0x0, et bits et chaînes n'étaient pas reportées du tout.
    7.1.0 Ajout du support de WebP.

    Exemples

    Exemple #2 Exemple avec getimagesize()

    <?php
    list($width, $height, $type, $attr) = getimagesize("img/flag.jpg");
    echo     "<img src=\"img/flag.jpg\" $attr alt=\"Exemple avec getimagesize()\" />";
    ?>

    Exemple #3 getimagesize() avec une URL

    <?php
    $size     = getimagesize("http://www.example.com/gifs/logo.gif");

    // Si le nom du fichier comporte des espaces, encodez-le !
    $size = getimagesize("http://www.example.com/gifs/lo%20go.gif");

    ?>

    Exemple #4 getimagesize() qui retourne IPTC

    <?php
    $size     = getimagesize("testimg.jpg", $info);
    if (isset(    $info["APP13"])) {
    $iptc = iptcparse($info["APP13"]);
    var_dump($iptc);
    }
    ?>

    Notes

    Note:

    Cette fonction ne nécessite pas la bibliothèque GD.

    Voir aussi

    add a note add a note

    User Contributed Notes 24 notes

    up
    79
    james dot relyea at zifiniti dot com
    15 years ago
    As noted below, getimagesize will download the entire image before it checks for the requested information. This is extremely slow on large images that are accessed remotely. Since the width/height is in the first few bytes of the file, there is no need to download the entire file. I wrote a function to get the size of a JPEG by streaming bytes until the proper data is found to report the width and height:

    <?php
    // Retrieve JPEG width and height without downloading/reading entire image.
    function getjpegsize($img_loc) {
            $handle = fopen($img_loc, "rb") or die("Invalid file stream.");
            $new_block = NULL;
        if(!    feof($handle)) {
                $new_block = fread($handle, 32);
                $i = 0;
            if(    $new_block[$i]=="\xFF" && $new_block[$i+1]=="\xD8" && $new_block[$i+2]=="\xFF" && $new_block[$i+3]=="\xE0") {
                    $i += 4;
                if(    $new_block[$i+2]=="\x4A" && $new_block[$i+3]=="\x46" && $new_block[$i+4]=="\x49" && $new_block[$i+5]=="\x46" && $new_block[$i+6]=="\x00") {
                        // Read block size and skip ahead to begin cycling through blocks in search of SOF marker
                        $block_size = unpack("H*", $new_block[$i] . $new_block[$i+1]);
                        $block_size = hexdec($block_size[1]);
                    while(!    feof($handle)) {
                            $i += $block_size;
                            $new_block .= fread($handle, $block_size);
                        if(    $new_block[$i]=="\xFF") {
                                // New block detected, check for SOF marker
                                $sof_marker = array("\xC0", "\xC1", "\xC2", "\xC3", "\xC5", "\xC6", "\xC7", "\xC8", "\xC9", "\xCA", "\xCB", "\xCD", "\xCE", "\xCF");
                            if(    in_array($new_block[$i+1], $sof_marker)) {
                                    // SOF marker detected. Width and height information is contained in bytes 4-7 after this byte.
                                    $size_data = $new_block[$i+2] . $new_block[$i+3] . $new_block[$i+4] . $new_block[$i+5] . $new_block[$i+6] . $new_block[$i+7] . $new_block[$i+8];
                                    $unpacked = unpack("H*", $size_data);
                                    $unpacked = $unpacked[1];
                                    $height = hexdec($unpacked[6] . $unpacked[7] . $unpacked[8] . $unpacked[9]);
                                    $width = hexdec($unpacked[10] . $unpacked[11] . $unpacked[12] . $unpacked[13]);
                                return array(    $width, $height);
                            } else {
                                    // Skip block marker and read block size
                                    $i += 2;
                                    $block_size = unpack("H*", $new_block[$i] . $new_block[$i+1]);
                                    $block_size = hexdec($block_size[1]);
                            }
                        } else {
                            return     FALSE;
                        }
                    }
                }
            }
        }
        return     FALSE;
    }
    ?>
    up
    15
    nikolam3244 at gmail dot com
    6 years ago
    There's a code snippet for getting JPEG image dimensions by getting only first few bytes of the file, but it doesn't work for PNG files, so I wrote one. It will download only the first 24 bytes instead of the whole image, and thus being much faster than getimagesize() and it will save bandwidth at the same time:

    <?php
    // Retrieve PNG width and height without downloading/reading entire image.
    function getpngsize( $img_loc ) {
            $handle = fopen( $img_loc, "rb" ) or die( "Invalid file stream." );

        if ( !     feof( $handle ) ) {
                $new_block = fread( $handle, 24 );
            if (     $new_block[0] == "\x89" &&
                    $new_block[1] == "\x50" &&
                    $new_block[2] == "\x4E" &&
                    $new_block[3] == "\x47" &&
                    $new_block[4] == "\x0D" &&
                    $new_block[5] == "\x0A" &&
                    $new_block[6] == "\x1A" &&
                    $new_block[7] == "\x0A" ) {
                    if (     $new_block[12] . $new_block[13] . $new_block[14] . $new_block[15] === "\x49\x48\x44\x52" ) {
                            $width  = unpack( 'H*', $new_block[16] . $new_block[17] . $new_block[18] . $new_block[19] );
                            $width  = hexdec( $width[1] );
                            $height = unpack( 'H*', $new_block[20] . $new_block[21] . $new_block[22] . $new_block[23] );
                            $height  = hexdec( $height[1] );

                        return array(     $width, $height );
                    }
                }
            }

        return     false;
    }
    ?>
    up
    13
    tomasz at trejderowski dot pl
    11 years ago
    If you want to "convert" value returned by "getimagesize()" as index "2" into something more human-readable, you may consider using a function like this one:

        $imageTypeArray = array
        (
            0=>'UNKNOWN',
            1=>'GIF',
            2=>'JPEG',
            3=>'PNG',
            4=>'SWF',
            5=>'PSD',
            6=>'BMP',
            7=>'TIFF_II',
            8=>'TIFF_MM',
            9=>'JPC',
            10=>'JP2',
            11=>'JPX',
            12=>'JB2',
            13=>'SWC',
            14=>'IFF',
            15=>'WBMP',
            16=>'XBM',
            17=>'ICO',
            18=>'COUNT' 
        );
       
        $size = getimagesize($filename);
       
        $size[2] = $imageTypeArray[$size[2]];

    Or something similar.
    up
    16
    php dot net at dannysauer dot com
    19 years ago
    Note that, if you're going to be a good programmer and use named constatnts (IMAGETYPE_JPEG) rather than their values (2), you want to use the IMAGETYPE variants - IMAGETYPE_JPEG, IMAGETYPE GIF, IMAGETYPE_PNG, etc.  For some reason, somebody made a horrible decision, and IMG_PNG is actually 4 in my version of PHP, while IMAGETYPE_PNG is 3.  It took me a while to figure out why comparing the type against IMG_PNG was failing...
    up
    5
    simon dot waters at surevine dot com
    9 years ago
    Note: getimage size doesn't attempt to validate image file formats

    It is possible for malformed GIF images to contain PHP and still have valid dimensions.

    Programmers need to ensure such images are validated by other tools, or never treated as PHP or other executable types (enforcing appropriate extensions, avoiding user controlled renaming, restricting uploaded images to areas of the website where PHP is not enabled).

    http://ha.ckers.org/blog/20070604/passing-malicious-php-through-getimagesize/
    up
    3
    info at personalmis dot com
    16 years ago
    Seems the various ways people are trying to proportionaly scale an image, up or down, could be more straight forward if one remembers ones algebra.

    The formula is, y = mx, where m is the slope of the line. This is the ratio of y:x or m = y/x.

    So if...

    // max values for x and y
    $y_max = 600;
    $x_max = 800;

    // image size
    $y1 = 2000;
    $x1 = 3000;

    // use width for scaling
    if ($x1 > $x_max)
    {
        // find slope
        $m = $y1/$x1;
        // set x side to max
        $x2 = $x_max;
        // set y side to a proportional size
        $y2 = $m * $x1;
    }

    The new image proportionally scaled will be x2 = 800, y2 = 533 (rounded).

    To do it from the y side, simply reverse the x's and y's.
    up
    3
    utilmind
    13 years ago
    Here is the function which determines whether the PNG image contains alpha or not:

    <?php
    function is_alpha_png($fn){
      return (    ord(@file_get_contents($fn, NULL, NULL, 25, 1)) == 6);
    }
    ?>

    The color type of PNG image is stored at byte offset 25. Possible values of that 25'th byte is:
    * 0 - greyscale
    * 2 - RGB
    * 3 - RGB with palette
    * 4 - greyscale + alpha
    * 6 - RGB + alpha
    up
    3
    redcore at gmail dot com
    17 years ago
    It's always good to check out an image's dimensions while attempting to upload to your server or database...especially if it's going to be displayed on a page that doesn't accomodate images beyond a particular size.

    <?php

    $tmpName     = $_FILES['userfile']['tmp_name'];
           
    list(    $width, $height, $type, $attr) = getimagesize($tmpName);

    if(    $width>275 || $height>275)
    {
    die(    "exceeded image dimension limits.");
    }

    ?>
    up
    5
    info at alex-lawrence dot com
    16 years ago
    Could be useful (didn´t know where to post it):

    function getImageErrors( $filename, $type = "", $minWidth = 0, $minHeight = 0, $maxWidth = 0, $maxHeight = 0, $maxFileSize = 0 )
    {
        $errors = array();
        if ( file_exists( $filename ) )
        {
            $ending = substr( $filename, strpos( $filename, "." ) );
            if ( is_array( $type ) )
            {
                $isTypeOf = false;
                foreach( $type as $eachtype )
                {
                    if ( $ending == $eachtype )
                    {
                        $isTypeOf = true;
                    }
                }
                if ( ! $isTypeOf )
                {
                    $errors[ 'type' ] = $ending;
                }
            }
            elseif ( $type != "" )
            {
                if ( $ending != $type )
                {
                    $errors[ 'type' ] = $ending;
                }
            }
            $size = getimagesize( $filename );
            if ( $size[ 0 ] < $minWidth )
            {
                $errors[ 'minWidth' ] = $size[ 0 ];
            }
            if ( $size[ 1 ] < $minHeight )
            {
                $errors[ 'minHeight' ] = $size[ 1 ];
            }
            if ( ( $maxWidth > $minWidth ) && ( $size[ 0 ] > $maxWidth ) )
            {
                $errors[ 'maxWidth' ] = $size[ 0 ];
            }
            if ( ( $maxHeight > $minHeight ) && ( $size[ 1 ] > $maxHeight ) )
            {
                $errors[ 'maxHeight' ] = $size[ 1 ];
            }
            if ( ( $maxFileSize > 0 ) && ( filesize( $filename ) > $maxFileSize ) )
            {
                $errors[ 'maxFileSize' ] = filesize( $filename );
            }
        }
        else
        {
            $errors[ 'filename' ] = "not existing";
        }
        return ( count( $errors ) > 0 ? $errors : null );
    }
    up
    3
    Steve
    13 years ago
    The list of defined IMAGETYPE_ constants is on the manual page for exif_imagetype:

    http://www.php.net/manual/en/function.exif-imagetype.php
    up
    2
    kazuya
    10 years ago
    i made function img_resize($path,$tmp_name,$new_name,$new_width)
    this could be useful.

    <?php

    $new_file     = img_resize("./img/", "test.jpg","copy_test.jpg",300);
    echo     "<IMG src = '$new_file'>";

    function     img_resize($path,$tmp_name,$new_name,$new_width){
        if (!    file_exists($path.$filename)){
            echo     "file not found!";
            exit;
        }
        if (!    is_writable($path)){
            echo     "error:permission denied!";
            exit;
        }
        list(    $width, $height) = getimagesize($path . $tmp_name);
            $new_height = abs($new_width * $height / $width);
            $image_p = imagecreatetruecolor($new_width, $new_height);
            $image = imagecreatefromjpeg($path . $tmp_name);
            imagecopyresampled($image_p, $image, 0, 0, 0, 0,
                                $new_width, $new_height, $width, $height);
            imagejpeg($image_p, $path . $new_name);
        return     $path.$new_name;
    }

    ?>
    up
    2
    shmohel at gmail dot com
    16 years ago
    Rather than making a lengthy function that essentially runs twice (once as width, once as height) I came up with a helpful function that uses variable variables to set a maximum height/width. Hope someone finds this helpful.

    function scaleimage($location, $maxw=NULL, $maxh=NULL){
        $img = @getimagesize($location);
        if($img){
            $w = $img[0];
            $h = $img[1];

            $dim = array('w','h');
            foreach($dim AS $val){
                $max = "max{$val}";
                if(${$val} > ${$max} && ${$max}){
                    $alt = ($val == 'w') ? 'h' : 'w';
                    $ratio = ${$alt} / ${$val};
                    ${$val} = ${$max};
                    ${$alt} = ${$val} * $ratio;
                }
            }

            return("<img src='{$location}' alt='image' width='{$w}' height='{$h}' />");
        }
    }
    up
    2
    geoff at spacevs dot com
    15 years ago
    This function returns the width and height of a JPEG image from a string, allowing the dimensions of images stored in a database to be retrieved without writing them to the disk first, or using "imagecreatefromstring" which is very slow in comparison.

    <?PHP
    function getJPEGImageXY($data) {
                $soi = unpack('nmagic/nmarker', $data);
            if (    $soi['magic'] != 0xFFD8) return false;
                $marker = $soi['marker'];
                $data   = substr($data, 4);
                $done   = false;

            while(    1) {
                    if (    strlen($data) === 0) return false;
                    switch(    $marker) {
                            case     0xFFC0:
                                        $info = unpack('nlength/Cprecision/nY/nX', $data);
                                    return array(    $info['X'], $info['Y']);
                                    break;

                            default:
                                        $info   = unpack('nlength', $data);
                                        $data   = substr($data, $info['length']);
                                        $info   = unpack('nmarker', $data);
                                        $marker = $info['marker'];
                                        $data   = substr($data, 2);
                                    break;
                    }
            }
    }
    ?>

    Doing this 10,000 times takes 0.43 seconds, compared with using imagecreatefromstring/imagesx/imagesy which takes around 1.52 seconds to do the same.

    Do not use this instead of getimagesize when dealing with files, getimagesize is much faster coming in at 0.15 seconds.
    up
    1
    cloned at clonedmadman dot com
    16 years ago
    Well, I am making a script which will resize the image when uploaded, however, i am making a multi-uploader, so i came across with a problem: an efficient way of getting a pictures height and width and storing them in an array to resize later. This is what i came up with:

    <?php
    $links     = array("test1.jpg", "test2.png");
    $sizearray = array();
    $count = count($links);
    for(    $i = 0; $i < $count; $i++) {
            $size = getimagesize($links[$i]);
        list(    $width, $height) = $size;
            $sizearray[$links[$i]] = array("width" => $width, "height" => $height);
    }
    print_r($sizearray);
    // which will print out: Array ( [test1.jpg] => Array ( [width] => 300 [height] => 400 ) [test2.png] => Array ( [width] => 680 [height] => 100 ) )
    ?>
    up
    1
    alexyam at live dot com
    12 years ago
    I wanted to use getimagesize() on .SWF files stored in the database as blob data and couldn't find a simple solution, so I created my own.

    I am releasing this code under the MIT license to save everyone some time:

    <?php
    /*
        ----------------------------------------------------------------------
        PHP Blob Data As File Stream v1.0 (C) 2012 Alex Yam <alexyam@live.com>
        This code is released under the MIT License.
        ----------------------------------------------------------------------
        [Summary]

        A simple class for PHP functions to read and write blob data as a file
        using a stream wrapper.

        Particularly useful for running getimagesize() to get the width and
        height of .SWF Flash files that are stored in the database as blob data.

        Tested on PHP 5.3.10.

        ----------------------------------------------------------------------   
        [Usage Example]

        //Include
            include('./blob_data_as_file_stream.php');

        //Register the stream wrapper
            stream_wrapper_register("BlobDataAsFileStream", "blob_data_as_file_stream");

        //Fetch a .SWF file from the Adobe website and store it into a variable.
        //Replace this with your own fetch-swf-blob-data-from-database code.
            $swf_url = 'http://www.adobe.com/swf/software/flash/about/flashAbout_info_small.swf';
            $swf_blob_data = file_get_contents($swf_url);
       
        //Store $swf_blob_data to the data stream
            blob_data_as_file_stream::$blob_data_stream = $swf_blob_data;
       
        //Run getimagesize() on the data stream
            $swf_info = getimagesize('BlobDataAsFileStream://');
            var_dump($swf_info);

        ----------------------------------------------------------------------
        [Usage Output]

        array(5) {
          [0]=>
          int(159)
          [1]=>
          int(91)
          [2]=>
          int(13)
          [3]=>
          string(23) "width="159" height="91""
          ["mime"]=>
          string(29) "application/x-shockwave-flash"
        }

    */

    class blob_data_as_file_stream {

        private static     $blob_data_position = 0;
        public static     $blob_data_stream = '';

        public static function     stream_open($path,$mode,$options,&$opened_path){
            static::    $blob_data_position = 0;
            return     true;
        }

        public static function     stream_seek($seek_offset,$seek_whence){
                $blob_data_length = strlen(static::$blob_data_stream);
            switch (    $seek_whence) {
                case     SEEK_SET:
                        $new_blob_data_position = $seek_offset;
                    break;
                case     SEEK_CUR:
                        $new_blob_data_position = static::$blob_data_position+$seek_offset;
                    break;
                case     SEEK_END:
                        $new_blob_data_position = $blob_data_length+$seek_offset;
                    break;
                default:
                    return     false;
            }
            if ((    $new_blob_data_position >= 0) AND ($new_blob_data_position <= $blob_data_length)){
                static::    $blob_data_position = $new_blob_data_position;
                return     true;
            }else{
                return     false;
            }
        }

        public static function     stream_tell(){
            return static::    $blob_data_position;
        }

        public static function     stream_read($read_buffer_size){
                $read_data = substr(static::$blob_data_stream,static::$blob_data_position,$read_buffer_size);
            static::    $blob_data_position += strlen($read_data);
            return     $read_data;
        }

        public static function     stream_write($write_data){
                $write_data_length=strlen($write_data);
            static::    $blob_data_stream = substr(static::$blob_data_stream,0,static::$blob_data_position).
                    $write_data.substr(static::$blob_data_stream,static::$blob_data_position+=$write_data_length);
            return     $write_data_length;
        }

        public static function     stream_eof(){
            return static::    $blob_data_position >= strlen(static::$blob_data_stream);
        }

    }
    ?>
    up
    1
    ajreading at classixshop dot com
    19 years ago
    A simple piece of code i wrote to proportionally resize an image to a max height and width then display it

    <?php
    // Max height and width
    $max_width = 100;
    $max_height = 100;

    // Path to your jpeg

    $upfile '/path/to/file.jpg';
            Header("Content-type: image/jpeg");
       
            $size = GetImageSize($upfile); // Read the size
                  $width = $size[0];
                  $height = $size[1];
             
                  // Proportionally resize the image to the
              // max sizes specified above
             
                  $x_ratio = $max_width / $width;
                  $y_ratio = $max_height / $height;

              if( (    $width <= $max_width) && ($height <= $max_height) )
              {
                       $tn_width = $width;
                       $tn_height = $height;
              }
              elseif ((    $x_ratio * $height) < $max_height)
              {
                       $tn_height = ceil($x_ratio * $height);
                       $tn_width = $max_width;
              }
              else
              {
                       $tn_width = ceil($y_ratio * $width);
                       $tn_height = $max_height;
              }
             // Increase memory limit to support larger files
        
             ini_set('memory_limit', '32M');
        
             // Create the new image!
             $src = ImageCreateFromJpeg($upfile);
             $dst = ImageCreateTrueColor($tn_width, $tn_height);
             ImageCopyResized($dst, $src, 0, 0, 0, 0, $tn_width, $tn_height, $width, $height);
             ImageJpeg($dst);
    // Destroy the images
    ImageDestroy($src);
    ImageDestroy($dst);
    ?>
    up
    1
    Jesus Zamora
    13 years ago
    Returns a array with 4 elements.
    The 0 index is the width of the image in pixels.
    The 1 index is the height of the image in pixels.
    The 2 index is a flag for the image type:

    1 = GIF, 2 = JPG, 3 = PNG, 4 = SWF, 5 = PSD, 6 = BMP, 7 = TIFF(orden de bytes intel), 8 = TIFF(orden de bytes motorola), 9 = JPC, 10 = JP2, 11 = JPX, 12 = JB2, 13 = SWC, 14 = IFF, 15 = WBMP, 16 = XBM.

    The 3 index contains ' height="yyy" width="xxx" '
    up
    1
    diablx at hotmail dot com
    20 years ago
    I'm sorry for they other scripts, but I made one mistake about the image resizing... here is a working script !
    <?
            // Some configuration variables !
            $maxWidth = 90;
            $maxHeight = 90;
            $maxCols = 8;
            $webDir = "https://localhost/images/";
            $localDir = $_SERVER['DOCUMENT_ROOT']."/images/";

            $AutorisedImageType = array ("jpg", "jpeg", "gif", "png");
    ?>

    <center>
    <table border='1' cellspacing='5' cellpadding='5' style="border-collapse:collapse; border-style: dotted">
    <tr>
       <?
           // Open localDir
           $dh = opendir($localDir);
       while (    false !== ($filename = readdir($dh))) {
               $filesArray[] = $filename;
       }

           // Display and resize
           foreach ($filesArray as $images) {
      
               $ext = substr($images, strpos($images, ".")+1, strlen($images));
          
           if(     in_array($ext, $AutorisedImageType) ) {

               list(    $width, $height, $type, $attr) = @getimagesize( $localDir.$images );

                    $xRatio = $maxWidth / $width;
                    $yRatio = $maxHeight / $height;
               
                if ( (    $width <= $maxWidth) && ($height <= $maxHeight) ) {
                      $newWidth = $width;
                      $newHeight = $height;
                }
                else if ((    $xRatio * $height) < $maxHeight) {
                      $newHeight = ceil($xRatio * $height);
                      $newWidth = $maxWidth;
                }
                else {
                      $newWidth = ceil($yRatio * $width);
                      $newHeight = $maxHeight;
                }
              
               if(    $i == $maxCols) {
                   echo     "</tr><tr>";
                       $i = 0;
               }
               echo     "<td align='center' valign='middle' width='$maxWidth' height='$maxHeight'><img src='".$webDir.$images."' width='$newWidth' height='$newHeight'></td>";
                   $i++;
           }
       }
    ?>
    </tr>
    </table>
    </center>
    up
    0
    freecorvette at gmail dot com
    7 years ago
    For some images, using getimagesize() without the second parameter will return the correct info, but when you add the second parameter it will return false. This is most likely a bug (and it has been reported as such), but meanwhile, if you encounter this problem, a workaround is to use exif_read_data().
    up
    0
    anonymous
    15 years ago
    Note that if you specify a remote file (via a URL) to check the size of, PHP will first download the remote file to your server.

    If you're using this function to check the size of user provided image links, this could constitute a security risk.  A malicious user could potentially link to a very large image file and cause PHP to download it.  I do not know what, if any, file size limits are in place for the download.  But suppose the user provided a link to an image that was several gigabytes in size?

    It would be nice if there were a way to limit the size of the download performed by this function.  Hopefully there is already a default with some sensible limits.
    up
    0
    mail at soylentgreens dot com
    19 years ago
    How about this for cropping images...

    <?php

    $imgfile     = "img.jpg";
    $cropStartX = 300;
    $cropStartY = 250;
    $cropW   = 200;
    $cropH   = 200;

    // Create two images
    $origimg = imagecreatefromjpeg($imgfile);
    $cropimg = imagecreatetruecolor($cropW,$cropH);

    // Get the original size
    list($width, $height) = getimagesize($imgfile);

    // Crop
    imagecopyresized($cropimg, $origimg, 0, 0, $cropStartX, $cropStartY, $width, $height, $width, $height);

    // TODO: write code to save new image
    // or, just display it like this:
    header("Content-type: image/jpeg");
    imagejpeg($cropimg);

    // destroy the images
    imagedestroy($cropimg);
    imagedestroy($origimg);

    ?>
    up
    -1
    Coodiss at w3bbix dot net
    19 years ago
    Heres a easy way to scale images to the <td> that they are in
    *this is broken up so anyone can understand it :)

    <?
    $imageinfo     = getimagesize("images/picture.jpg");
             
    $ix=$imageinfo[0];
    $iy=$imageinfo[1];

    $widthscale = $ix/175;  //<TD> WIDTH
    $heightscale = $iy/175; //<TD> HEIGHT

    if($widthscale < 1)
    $nwidth = $ix*$widthscale;
    else
    $nwidth = $ix/$widthscale;

    if(    $heightscale < 1)
    $nheight = $iy*$heightscale;
    else
    $nheight = $iy/$heightscale;

    ?>
    up
    -1
    user at example dot net
    16 years ago
    When validating images, allways check both, image type *AND* file extension!

    Because most image types allow sections for comments or other irrelevant data. Those section can be used to infiltrate php code onto the server. If these files are stored as sent by the client, files with a ".php" extension can be executed and do tremendous harm.
    up
    -1
    pfarthing at hotmail dot com
    16 years ago
    Correction: to find $y2 it should be...

    // set y side to a proportional size
    $y2 = $m * $x_max; // not $x1

    Thanks Norbert =)
    add a note add a note
    To Top