PHP 7.0.6 Released

    GD and Image Functions

    Table of Contents

    User Contributed Notes

    shd at earthling dot net
    10 years ago
    If you happen to need a way to output a Windows BMP file (e.g. when using the PEAR ExcelWriter), feel free to use the following code:

    <?php
    function imagebmp ($im, $fn = false)
    {
        if (!    $im) return false;
               
        if (    $fn === false) $fn = 'php://output';
            $f = fopen ($fn, "w");
        if (!    $f) return false;
               
            //Image dimensions
            $biWidth = imagesx ($im);
            $biHeight = imagesy ($im);
            $biBPLine = $biWidth * 3;
            $biStride = ($biBPLine + 3) & ~3;
            $biSizeImage = $biStride * $biHeight;
            $bfOffBits = 54;
            $bfSize = $bfOffBits + $biSizeImage;
               
            //BITMAPFILEHEADER
            fwrite ($f, 'BM', 2);
            fwrite ($f, pack ('VvvV', $bfSize, 0, 0, $bfOffBits));
               
            //BITMAPINFO (BITMAPINFOHEADER)
            fwrite ($f, pack ('VVVvvVVVVVV', 40, $biWidth, $biHeight, 1, 24, 0, $biSizeImage, 0, 0, 0, 0));
               
            $numpad = $biStride - $biBPLine;
        for (    $y = $biHeight - 1; $y >= 0; --$y)
        {
            for (    $x = 0; $x < $biWidth; ++$x)
            {
                    $col = imagecolorat ($im, $x, $y);
                    fwrite ($f, pack ('V', $col), 3);
            }
            for (    $i = 0; $i < $numpad; ++$i)
                    fwrite ($f, pack ('C', 0));
        }
            fclose ($f);
        return     true;
    }
    ?>

    It works the same way as regular imagejpeg/imagepng do and only supports GD2.0 true colour bitmaps (which is what's required by ExcelWriter).
    felipensp at gmail dot com
    10 years ago
    Representation decimal of a color in hexadecimal for use on functions of library GD.

    <?php

            // Representation hexadecimal
            $var = '#FFFFFF';

        function     getRgbFromGd($color_hex) {

            return     array_map('hexdec', explode('|', wordwrap(substr($color_hex, 1), 2, '|', 1)));

        }
       
            print_r(getRgbFromGd($var));

            // Output: Array ( [0] => 255 [1] => 255 [2] => 255 )

    ?>
    chuckstudios at gmail dot com
    7 years ago
    I wrote a simple function to convert an image resource to PGM (portable graymap) in order to feed it to an OCR program. It works just like the rest of the image output functions, and will convert to grayscale for you:

    <?php
            function imagepgm($image, $filename = null)
        {
                $pgm = "P5 ".imagesx($image)." ".imagesy($image)." 255\n";
            for(    $y = 0; $y < imagesy($image); $y++)
            {
                for(    $x = 0; $x < imagesx($image); $x++)
                {
                        $colors = imagecolorsforindex($image, imagecolorat($image, $x, $y));
                        $pgm .= chr(0.3 * $colors["red"] + 0.59 * $colors["green"] + 0.11 * $colors["blue"]);
                }
            }
            if(    $filename != null)
            {
                    $fp = fopen($filename, "w");
                    fwrite($fp, $pgm);
                    fclose($fp);
            }
            else
            {
                return     $pgm;
            }
        }
    ?>
    jeff at lushmedia dot com
    12 years ago
    I wrote an online overview of the image functions that people might find useful. In addition to a general overview of the various function categories and code samples, I have included many interactive examples of the functions, allowing viewers to experiment with the parameters, and seeing the results in real time. The presentation is located at New York PHP
    http://www.nyphp.org/content/presentations/GDintro/
    michal-ok at o2 dot pl
    10 years ago
    The image sharpen function (by Alex R. Austin) provided below seems to be very resource hungry and I couldn't make it work on two different servers - trying to sharpen a 413 x 413 image I ended up with "Fatal error: Allowed memory size of 8388608 bytes exhausted" or "Internal Server Error" or the script terminated without notice. Because I had no priviliges to change the default memory limit on these servers I started looking for other sharpen functions. I have come across a php Unsharp Mask function which works like a charm on both of the servers I dealt with. It can be found at http://vikjavev.no/hovudsida/umtestside.php.
    ingo at jache dot de
    4 years ago
    I know this might look somewhat superfluous to others, but i once came across a situation where i needed a *strong* blur on an image without having ImageMagick installed. Executing the convolution-filter several times on the same image is awfully slow and still doesn't give a good blur.

    The function below accepts a truecolor-image and a blur-factor between 0.0 and 1.0. Beware: It's still quite slow.

    <?php

            function blurImage($srcimg,$blur)
        {
                $blur = $blur*$blur;
                $blur = max(0,min(1,$blur));
       
                $srcw = imagesx($srcimg);
                $srch = imagesy($srcimg);
           
                $dstimg = imagecreatetruecolor($srcw,$srch);
       
                $f1a = $blur;
                $f1b = 1.0 - $blur;

       
                $cr = 0; $cg = 0; $cb = 0;
                $nr = 0; $ng = 0; $nb = 0;

                $rgb = imagecolorat($srcimg,0,0);
                $or = ($rgb >> 16) & 0xFF;
                $og = ($rgb >> 8) & 0xFF;
                $ob = ($rgb) & 0xFF;

                //-------------------------------------------------
            // first line is a special case
            //-------------------------------------------------
                $x = $srcw;
                $y = $srch-1;
            while (    $x--)
            {
                    //horizontal blurren
                    $rgb = imagecolorat($srcimg,$x,$y);
                    $cr = ($rgb >> 16) & 0xFF;
                    $cg = ($rgb >> 8) & 0xFF;
                    $cb = ($rgb) & 0xFF;
       
                    $nr = ($cr * $f1a) + ($or * $f1b);
                    $ng = ($cg * $f1a) + ($og * $f1b);
                    $nb = ($cb * $f1a) + ($ob * $f1b);   

                    $or = $nr;
                    $og = $ng;
                    $ob = $nb;
               
                    imagesetpixel($dstimg,$x,$y,($nr << 16) | ($ng << 8) | ($nb));
            }
                //-------------------------------------------------

            //-------------------------------------------------
            // now process the entire picture
            //-------------------------------------------------
                $y = $srch-1;
            while (    $y--)
            {

                    $rgb = imagecolorat($srcimg,0,$y);
                    $or = ($rgb >> 16) & 0xFF;
                    $og = ($rgb >> 8) & 0xFF;
                    $ob = ($rgb) & 0xFF;

                    $x = $srcw;
                while (    $x--)
                {
                        //horizontal
                        $rgb = imagecolorat($srcimg,$x,$y);
                        $cr = ($rgb >> 16) & 0xFF;
                        $cg = ($rgb >> 8) & 0xFF;
                        $cb = ($rgb) & 0xFF;
                   
                        $nr = ($cr * $f1a) + ($or * $f1b);
                        $ng = ($cg * $f1a) + ($og * $f1b);
                        $nb = ($cb * $f1a) + ($ob * $f1b);   
       
                        $or = $nr;
                        $og = $ng;
                        $ob = $nb;
                   
                   
                        //vertical
                        $rgb = imagecolorat($dstimg,$x,$y+1);
                        $vr = ($rgb >> 16) & 0xFF;
                        $vg = ($rgb >> 8) & 0xFF;
                        $vb = ($rgb) & 0xFF;
                   
                        $nr = ($nr * $f1a) + ($vr * $f1b);
                        $ng = ($ng * $f1a) + ($vg * $f1b);
                        $nb = ($nb * $f1a) + ($vb * $f1b);   
       
                        $vr = $nr;
                        $vg = $ng;
                        $vb = $nb;
                   
                        imagesetpixel($dstimg,$x,$y,($nr << 16) | ($ng << 8) | ($nb));
                }
           
            }
                //-------------------------------------------------
                return $dstimg;       

        }

       
            $srcimg = imagecreatefromjpeg("test.jpg");
            $dstimg = blurImage($srcimg,0.2);

            header('Content-type: image/jpeg');
        echo(     imagejpeg($dstimg) );
        exit();
       
       
    ?>
    ph_corp at yahoo dot fr
    8 years ago
    <?php

    /**
    HSL/RGB conversion functions
    very useful for a lot of applications
    **/

    function RBGtoHSL ( $R, $G, $B )
    {

            $var_R = ( $R / 255 );
            $var_G = ( $G / 255 );
            $var_B = ( $B / 255 );

            $var_Min = min( $var_R, $var_G, $var_B )
            $var_Max = max( $var_R, $var_G, $var_B )
            $del_Max = $var_Max - $var_Min

        $L     = ( $var_Max + $var_Min ) / 2;

        if (     $del_Max == 0 )
        {
               $H = 0
           $S     = 0
            }
        else
        {
            if (     $L < 0.5 )
            {
                    $S = $del_Max / ( $var_Max + $var_Min );
            }
            else
            {
                    $S = $del_Max / ( 2 - $var_Max - $var_Min );
            }

                $del_R = ( ( ( $var_Max - $var_R ) / 6 ) + ( $del_Max / 2 ) ) / $del_Max;
                $del_G = ( ( ( $var_Max - $var_G ) / 6 ) + ( $del_Max / 2 ) ) / $del_Max;
                $del_B = ( ( ( $var_Max - $var_B ) / 6 ) + ( $del_Max / 2 ) ) / $del_Max;

            if (     $var_R == $var_Max )
            {
                    $H = $del_B - $del_G;
            }
            else if (     $var_G == $var_Max )
            {
                    $H = ( 1 / 3 ) + $del_R - $del_B;
            }
            else if (     $var_B == $var_Max )
            {
                    $H = ( 2 / 3 ) + $del_G - $del_R;
            }

            if (     $H < 0 )
            {
                    $H += 1;
            }
            if (     $H > 1 )
            {
                    $H -= 1
                }

        }

        return array(     $H, $S, $L );

    }

    function     HuetoRGB( $v1, $v2, $vH )
    {
        if (     $vH < 0 )
        {
                $vH += 1;
        }
        if (     $vH > 1 )
        {
                $vH -= 1;
        }
        if ( (     6 * $vH ) < 1 )
        {
            return (     $v1 + ( $v2 - $v1 ) * 6 * $vH );
        }
        if ( (     2 * $vH ) < 1 )
        {
            return (     $v2 );
        }
        if ( (     3 * $vH ) < 2 )
        {
            return (     $v1 + ( $v2 - $v1 ) * ( ( 2 / 3 ) - $vH ) * 6 );
        }
        return (     $v1 )
    }

    function     HSLtoRGB ( $H, $S, $L )
    {

        if (     $S == 0 )
        {
                $R = $L * 255;
                $G = $L * 255;
                $B = $L * 255;
        }
        else
        {
            if (     $L < 0.5 )
            {
                    $var_2 = $L * ( 1 + $S );
            }
            else
            {
                    $var_2 = ( $L + $S ) - ( $S * $L );
            }

                $var_1 = 2 * $L - $var_2;

                $R = 255 * HuetoRGB( $var_1, $var_2, $H + ( 1 / 3 ) );
                $G = 255 * HuetoRGB( $var_1, $var_2, $H );
                $B = 255 * HuetoRGB( $var_1, $var_2, $H - ( 1 / 3 ) );
        }

        return array(     $R, $G, $B );

    }

    function     distance ( $R1, $G1, $B1, $R2, $G2, $B2 )
    {
            $result = sqrt ( ( $R1 - $R2 )*( $R1 - $R2 ) + ( $G1 - $G2 )*( $G1 - $G2 ) + ( $B1 - $B2 )*( $B1 - $B2 ) );
        return (     $result );
    }

    ?>
    dev at kingthief dot com
    8 years ago
    I've developed a well-documented, fairly rock-solid API for creating on the fly, anti-aliased, rounded corner images, including full alpha transparency support for all you PNG lovers.

    go here to download the package:
    http://sourceforge.net/projects/roundedphp/

    go here for a live demo:
    http://dev.kingthief.com/demos/roundedphp/

    Installation is similar to PEAR.

    Enjoy!
    peter dot hulstaert at gmail dot com
    10 years ago
    While I was searching for a good way to draw a graph, I stumbled on skumar2k15's script.

    I have taken the liberty to improve multiple aspects of it.

    1. The array can grow and shrink in size, the graph will adjust accordingly.
    2. All the values in the array are recalculated so they won't get bigger than the height of the graph.
    3. I inserted the possibility to keep a percentage off the height away from the edge.
    4. You can adjust the size of the grid.
    5. Everything will adjust when you change the height of width.

    <?
    header("Content-type: image/png");

    // Define variables
    $Values=array(50,90,30,155,50,40,320,50,40,86,240,128,650,540,320);
    $imgWidth=500;
    $imgHeight=200;
    $grid=25;
    $graphspacing=0.05;

    //Creation of new array with hight adjusted values
    while (list($key, $val) = each($Values))
        {if($val>$max){$max=$val;}}

    for ($i=0; $i<count($Values); $i++){
    $graphValues[$i] = $Values[$i] * (($imgHeight*(1-$graphspacing))/$max);
    }
    // Create image and define colors

    $image=imagecreate($imgWidth, $imgHeight);
    $colorWhite=imagecolorallocate($image, 255, 255, 255);
    $colorGrey=imagecolorallocate($image, 192, 192, 192);
    $colorBlue=imagecolorallocate($image, 0, 0, 255);

    // Create border around image
    imageline($image, 0, 0, 0, $imgHeight, $colorGrey);
    imageline($image, 0, 0, $imgWidth, 0, $colorGrey);
    imageline($image, $imgWidth-1, 0, $imgWidth-1, $imgHeight-1, $colorGrey);
    imageline($image, 0, $imgHeight-1, $imgWidth-1, $imgHeight-1, $colorGrey);

    // Create grid
    for ($i=1; $i<($imgWidth/$grid); $i++)
        {imageline($image, $i*$grid, 0, $i*$grid, $imgHeight, $colorGrey);}
    for ($i=1; $i<($imgHeight/$grid); $i++)
        {imageline($image, 0, $i*$grid, $imgWidth, $i*$grid, $colorGrey);}

    // Create line graph
    if($imgWidth/$grid>count($graphValues)){$space=$grid;}
    else{$space = $imgWidth/(count($graphValues)-1);}

    for ($i=0; $i<count($graphValues)-1; $i++)
        {imageline($image, $i*$space, ($imgHeight-$graphValues[$i]), ($i+1)*$space, ($imgHeight-$graphValues[$i+1]), $colorBlue);}

    // Output graph and clear image from memory
    imagepng($image);
    imagedestroy($image);
    ?>
    mslemko
    10 years ago
    For fedora core 4 users that find that the gd library isn't installed, you can issue the command (as root)

    # yum install php-gd

    it should download and install the gd library. You will need to restart apache... phpinfo() should then tell you "GD Support     enabled".
    timeshifting at gmail dot com
    10 years ago
    To sharpen an image, rather than using the code below that produces a sharpening filter with php, use the built-in GD function "imageconvolution" which is designed for this purpose. Matrices can be used for sharpening, blurring, edge detection, etc, ala Photoshop.

    A sharpening example:

    <?php

    $sharpenMatrix     = array(-1,-1,-1,-1,16,-1,-1,-1,-1);
    $divisor = 8;
    $offset = 0;

    imageconvolution($myImage, $sharpenMatrix, $divisor, $offset);

    ?>

    Below is some information on building different kinds of matrices. (If you have photoshop (or PSP, GIMP) you can test out your matrices before applying them in PHP)

    http://loriweb.pair.com/8udf-basics.html (covers blurs)
    http://loriweb.pair.com/8udf-sharpen.html
    http://loriweb.pair.com/8udf-edges.html
    http://loriweb.pair.com/8udf-emboss.html
    str_replace(&#39;o&#39;, &#39;x&#39;, &#39;nitrogen&#39;);
    1 year ago
    I was after a technique to produce an image by using the image resources available to PHP and to have access to the image's binary data directly in PHP WITHOUT saving to a temporary file.

    My purpose of this was to produce a directory of images with small image thumbnails (16x16) next to the filenames. Instead of having countless tiny images saved, I wanted to print out the image data into the <img> HTML tag (inline) using the data URI scheme.

    I found no such code or suggestion for this, and I've done some digging around at likely approaches and finally came up with a solution. There may or may not be a better way of doing this, but this way works for me.

    The guts of the approach started here with the example of registering a class as a stream wrapper: http://php.net/manual/en/stream.streamwrapper.example-1.php - this way we have access to, and can over-ride, the behaviour of "file" I/O with a custom wrapper.

    <?php

    // first, we define our class for the stream wrapper
    class VariableStream {
      var     $position;
      var     $varname;

      function     stream_open($path, $mode, $options, &$opened_path) {
            $url = parse_url($path);
            $this->varname = $url['host'];
            $this->position = 0;
        return     TRUE;
      }

      function     stream_write($data) {
            $left = substr(@$GLOBALS[$this->varname], 0, $this->position);
            $right = substr(@$GLOBALS[$this->varname], $this->position+strlen($data));
            $GLOBALS[$this->varname] = $left.$data.$right;
            $this->position+= strlen($data);
        return     strlen($data);
      }

      function     stream_eof() {
        return     $this->position>=strlen($GLOBALS[$this->varname]);
      }
    }

    // register the class as a stream wrapper ("var://asdf")
    stream_wrapper_register('var', 'VariableStream');

    // create a really simple dynamically-generated image
    // in my case, I used imagecreatefromjpeg to create 16x16 thumbnails
    $im = imagecreatetruecolor(130, 36);
    imagefill($im, 0, 0, 0xAAAAAA);
    imagestring($im, 5, 10, 10, 'Hello world!', 0x0000FF);

    // and output it to our wrapper!
    imagepng($im, 'var://asdf/'); // $asdf now contains our image binary!
    imagedestroy($im); // free memory

    $asdf = base64_encode($asdf); // base64 encode our data for...
    printf("<img alt=\"\" src=\"data:image/png;base64,%s\"/>", $asdf);

    ?>

    The class 'VariableStream' lacks ability to seek, ftell, and read for the sake of simple code for my purpose. More complete code for I/O operations can be found in the example document I references above. You could also then use fopen using the wrapper and variable name to access it like a file again.

    This technique can be applied to other functions that don't allow direct access to the data generated to files or sockets.

    Hope this helps!
    sellout at NoSpAm dot dharmadevil dot com
    13 years ago
    A fun little function to output UPC-A 11-digit barcodes.
    Thanks to barcodeisland.com for the specs.

    <?php

    function UPCAbarcode($code) {
          $lw = 2; $hi = 100;
          $Lencode = array('0001101','0011001','0010011','0111101','0100011',
                           '0110001','0101111','0111011','0110111','0001011');
          $Rencode = array('1110010','1100110','1101100','1000010','1011100',
                           '1001110','1010000','1000100','1001000','1110100');
          $ends = '101'; $center = '01010';
          /* UPC-A Must be 11 digits, we compute the checksum. */
          if ( strlen($code) != 11 ) { die("UPC-A Must be 11 digits."); }
          /* Compute the EAN-13 Checksum digit */
          $ncode = '0'.$code;
          $even = 0; $odd = 0;
      for (    $x=0;$x<12;$x++) {
        if (    $x % 2) { $odd += $ncode[$x]; } else { $even += $ncode[$x]; }
      }
          $code.=(10 - (($odd * 3 + $even) % 10)) % 10;
          /* Create the bar encoding using a binary string */
          $bars=$ends;
          $bars.=$Lencode[$code[0]];
      for(    $x=1;$x<6;$x++) {
            $bars.=$Lencode[$code[$x]];
      }
          $bars.=$center;
      for(    $x=6;$x<12;$x++) {
            $bars.=$Rencode[$code[$x]];
      }
          $bars.=$ends;
          /* Generate the Barcode Image */
          $img = ImageCreate($lw*95+30,$hi+30);
          $fg = ImageColorAllocate($img, 0, 0, 0);
          $bg = ImageColorAllocate($img, 255, 255, 255);
          ImageFilledRectangle($img, 0, 0, $lw*95+30, $hi+30, $bg);
          $shift=10;
      for (    $x=0;$x<strlen($bars);$x++) {
        if ((    $x<10) || ($x>=45 && $x<50) || ($x >=85)) { $sh=10; } else { $sh=0; }
        if (    $bars[$x] == '1') { $color = $fg; } else { $color = $bg; }
            ImageFilledRectangle($img, ($x*$lw)+15,5,($x+1)*$lw+14,$hi+5+$sh,$color);
      }
          /* Add the Human Readable Label */
          ImageString($img,4,5,$hi-5,$code[0],$fg);
      for (    $x=0;$x<5;$x++) {
            ImageString($img,5,$lw*(13+$x*6)+15,$hi+5,$code[$x+1],$fg);
            ImageString($img,5,$lw*(53+$x*6)+15,$hi+5,$code[$x+6],$fg);
      }
          ImageString($img,4,$lw*95+17,$hi-5,$code[11],$fg);
          /* Output the Header and Content. */
          header("Content-Type: image/png");
          ImagePNG($img);
    }

    UPCAbarcode('12345678901');

    ?>
    To Top