Here are some PHP Functions for Images which I came across recently, these come under GD and Image Functions and require GD library. I have taken most of these from PHP Manual and they are quite helpful.

Sharpening All Images

function imagesharpen($image) {
    $matrix = array(array(-1, -1, -1), array(-1, 16, -1), array(-1, -1, -1), );
    $divisor = array_sum(array_map('array_sum', $matrix));
    $offset = 0;
    imageconvolution($image, $matrix, $divisor, $offset);
    return $image;
}

Sharpening Images via Function

<?php
function GDThrowError($message) { 
    // don't throw plain text errors in a function that's supposed to return an image 
    // as per "the principle of least astonishment": the user is expecting 
    // a jpeg, and they'll be less astonished to get a JPEG error message 
    // than they would be if they got plain text.  Imagine this was called 
    // from an image tag, which makes sense, that's how you use images: 
    // plain text errors won't even reach most users, they'd have to copy 
    // the img src into the address bar.  It probably wont' even occur to 
    // them, as it's not typically helpful to view the source of an image 
    // resource. 
    $font = 2; 
    // create a canvas with a bit of padding 
    $errimg = imagecreate((imagefontwidth($font) * strlen($message)) + 20, imagefontheight($font) + 10); 
    $bg = imagecolorallocate($errimg, 255, 255, 255); 
    $textcol = imagecolorallocate($errimg, 0, 0, 0); 
    imagestring($errimg, 2, 10, 5, $message, $textcol); 
    header('Content-type: image/jpeg');  
    imagejpeg($errimg); 
    imagedestroy($errimg); 
} 

function GDMakeJpegLookLikeCrap($target) { 
    // image dimensions are no longer needed (see below), but getimagesize can do some simple validation 
    if (($dims = @getimagesize($target)) === false || $dims['mime'] != 'image/jpeg') 
    { 
        GDThrowError('The file you specified couldn\'t be found or is not a valid jpeg image.  Make sure you spelled it correctly and provided the correct path.'); 
       return(false); 
    } 
    // the original function creates a new image and resamples the source to it using the same height and width here. 
    // I imagine this was to add future resizing functionality but as it is it does nothing but waste resources 
    $image = imagecreatefromjpeg($target); 
    // don't really know/care what this is.  If you're interested see http://us2.php.net/imageconvolution         
    // try tweaking these three vars for different effects, but there is a sharpening function in the php docs (above links) and it's not a trivial operation 
    $spnMatrix = array( array(-1,-1,-1,), 
                        array(-1,16,-1,), 
                        array(-1,-1,-1));  
    $divisor = 8;  
    $offset = 0;  
    imageconvolution($image, $spnMatrix, $divisor, $offset);  
    // I like to send headers as late as possible to avoid already sent errors and duplicate header content 
    header('Content-type: image/jpeg');  
    imagejpeg($image, null, 100);  
    imagedestroy($image);   
} 

// example call 
$s_image = (isset($_GET['image'])) ? $_GET['image'] : null; 

if (preg_match('/\.(jpg|jpeg)$/i', $s_image)) { 
    GDMakeJpegLookLikeCrap($s_image);   
} else { 
    GDThrowError('Please specify a jpeg file to sharpen in the form: ' . $_SERVER['PHP_SELF'] . '?image=filename.jpg'); 
} 
?>

Convert Image To PGM/Grayscale

<?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;
    }
}
?>

Giving Image Sepia Effect

<?php
// replace with your files
$originalFileName    = $filename;
$destinationFileName = "2".$filename;

// create a copy of the original image
// works with jpg images
// fell free to adapt to other formats ;)
$fullPath = explode(".",$originalFileName);
$lastIndex = sizeof($fullPath) - 1;
$extension = $fullPath[$lastIndex];
if (preg_match("/jpg|jpeg|JPG|JPEG/", $extension))
{
    $sourceImage = imagecreatefromjpeg($originalFileName);
}

// get image dimensions
$img_width  = imageSX($sourceImage);
$img_height = imageSY($sourceImage);

// convert to grayscale
// note: this will NOT affect your original image, unless
// originalFileName and destinationFileName are the same
for ($y = 0; $y <$img_height; $y++) { 
    for ($x = 0; $x <$img_width; $x++) { 
        $rgb = imagecolorat($sourceImage, $x, $y);
        $red   = ($rgb >> 16) & 0xFF; 
        $green = ($rgb >> 8) & 0xFF; $blue = $rgb & 0xFF; //sepia; 
        $red2 = min($red*.393 + $green*.769 + $blue*.189,255); 
        $green2 = min($red*.349 + $green*.686 + $blue*.168,255); 
        $blue2 = min($red*.272 + $green*.534 + $blue*.131,255); // shift gray level to the left $grayR = $red2 << 16;
        // R: red $grayG = $green2 << 8 ;
        // G: green $grayB = $blue2;
        // B: blue // OR operation to compute gray value $grayColor = $grayR | $grayG | $grayB; // set the pixel color imagesetpixel ($sourceImage, $x, $y, $grayColor); imagecolorallocate ($sourceImage, $gray, $gray, $gray);
    } 
} // copy pixel values to new file buffer
$destinationImage = ImageCreateTrueColor($img_width, $img_height); 
imagecopy($destinationImage, $sourceImage, 0, 0, 0, 0, $img_width, $img_height); // create file on disk imagejpeg($destinationImage, $destinationFileName); // destroy temp image buffers imagedestroy($destinationImage); imagedestroy($sourceImage); 
?>

Image Reflection

<?php
function imagereflection($src_img) {
  $src_height = imagesy($src_img);
  $src_width = imagesx($src_img);
  $dest_height = $src_height + ($src_height / 2);
  $dest_width = $src_width;

  $reflected = imagecreatetruecolor($dest_width, $dest_height);
  imagealphablending($reflected, false);
  imagesavealpha($reflected, true);

  imagecopy($reflected, $src_img, 0, 0, 0, 0, $src_width, $src_height);
  $reflection_height = $src_height / 2;
  $alpha_step = 80 / $reflection_height;
  for ($y = 1; $y <= $reflection_height; $y++) {
    for ($x = 0; $x < $dest_width; $x++) {
      // copy pixel from x / $src_height - y to x / $src_height + y
      $rgba = imagecolorat($src_img, $x, $src_height - $y);
      $alpha = ($rgba & 0x7F000000) >> 24; $alpha = max($alpha, 47 + ($y * $alpha_step)); $rgba = imagecolorsforindex($src_img, $rgba); $rgba = imagecolorallocatealpha($reflected, $rgba['red'], $rgba['green'], $rgba['blue'], $alpha); imagesetpixel($reflected, $x, $src_height + $y - 1, $rgba); } } return $reflected; } 
?>

Putting Text Vertically On Images

<?php
$string = 'Your Text';
$font_size = 2;
$img = imagecreate(20,90);
$bg = imagecolorallocate($img,225,225,225);
$black = imagecolorallocate($img,0,0,0);

$len = strlen($string);
for ($i=1; $i<=$len; $i++) {
    imagecharup($img, $font_size, 5, imagesy($img)-($i*imagefontwidth($font_size)), $string, $black);
    $string = substr($string,1);
}
header('Content-type: image/png');
imagepng($img);
imagedestroy($img);
?>

Putting Watermark On Images Watermark can be a png(with transparency) and can be placed anywhere on the image.

<?php 
function imagelogo (&$dst_image, $src_image, $dst_w, $dst_h, $src_w, $src_h, $position='bottom-left') { 
    imagealphablending($dst_image,true); 
    imagealphablending($src_image,true); 
    if ($position == 'random') { 
        $position = rand(1,8); 
    } 
    switch ($position) { 
        case 'top-right': 
        case 'right-top': 
        case 1: 
            imagecopy($dst_image, $src_image, ($dst_w-$src_w), 0, 0, 0, $src_w, $src_h); 
        break; 
        case 'top-left': 
        case 'left-top': 
        case 2: 
            imagecopy($dst_image, $src_image, 0, 0, 0, 0, $src_w, $src_h); 
        break; 
        case 'bottom-right': 
        case 'right-bottom': 
        case 3: 
            imagecopy($dst_image, $src_image, ($dst_w-$src_w), ($dst_h-$src_h), 0, 0, $src_w, $src_h); 
        break; 
        case 'bottom-left': 
        case 'left-bottom': 
        case 4: 
            imagecopy($dst_image, $src_image, 0 , ($dst_h-$src_h), 0, 0, $src_w, $src_h); 
        break; 
        case 'center': 
        case 5: 
            imagecopy($dst_image, $src_image, (($dst_w/2)-($src_w/2)), (($dst_h/2)-($src_h/2)), 0, 0, $src_w, $src_h); 
        break; 
        case 'top': 
        case 6: 
            imagecopy($dst_image, $src_image, (($dst_w/2)-($src_w/2)), 0, 0, 0, $src_w, $src_h); 
        break; 
        case 'bottom': 
        case 7: 
            imagecopy($dst_image, $src_image, (($dst_w/2)-($src_w/2)), ($dst_h-$src_h), 0, 0, $src_w, $src_h); 
        break; 
        case 'left': 
        case 8: 
            imagecopy($dst_image, $src_image, 0, (($dst_h/2)-($src_h/2)), 0, 0, $src_w, $src_h); 
        break; 
        case 'right': 
        case 9: 
            imagecopy($dst_image, $src_image, ($dst_w-$src_w), (($dst_h/2)-($src_h/2)), 0, 0, $src_w, $src_h); 
        break; 
    } 
} 

// example: 

imagelogo($image, $watermark, imagesx($image), imagesy($image), imagesx($watermark), imagesy($watermark), 'random'); 

?> {/code}

Make White Background Transparent

<?php

function transparentImage($src){  //making images with white bg transparent
$r1=80;
$g1=80;
$b1=80;
for($x = 0; $x < imagesx($src); ++$x)
        {
            for($y = 0; $y < imagesy($src); ++$y)
            {
                $color=imagecolorat($src, $x, $y);
                $r = ($color >> 16) & 0xFF; $g = ($color >> 8) & 0xFF; $b = $color & 0xFF; for($i=0;$i<270;$i++){ if($r.$g.$b==($r1+$i).($g1+$i).($b1+$i)){ $trans_colour = imagecolorallocatealpha($src, 0, 0, 0, 127); imagefill($src, $x, $y, $trans_colour); } } } } return $src; } $image='abc/abc.jpg'; $src = imagecreatefromjpeg($image); $src=transparentImage($src); //Lets make the jpegs transparent ?>

Crop Blank Edges From Image

<?php 
/** 
* $image image cursor (from imagecreatetruecolor) 
* $backgound image curosr (from imagecolorallocate) 
* $paddng int 
*/ 
function imageCrop($image, $background = false, $padding = 0) { 
    if($background) 
      $background = imagecolorallocate($image, 255, 255, 255); 

    $top = imageSY($image); 
    $left = imageSX($image); 
    $bottom = 0; 
    $right = 0; 

    for ($x = 0 ; $x < imagesx($image) ; $x++) { 
        for ($y = 0 ; $y < imagesy($image) ; $y++) { 

          // if there match 
            if(imagecolorat($image, $x, $y) != $background) { 

              if($x < $left) 
                $left = $x; 
              if($x > $right) $right = $x; if($y > $bottom) $bottom = $y; if($y < $top) $top = $y; } } } $right++; $bottom++; // create new image with padding $img = imagecreatetruecolor($right-$left+$padding\*2,$bottom-$top+$padding\*2); // fill the background imagefill($img, 0, 0, $background); // copy imagecopy($img, $image, $padding, $padding, $left, $top, $right-$left, $bottom-$top); // destroy old image cursor imagedestroy($image); return $img; } ?>

Yes, using simple PHP snippet you can limit the download speed of a file. This can be done for Bandwidth throttling or for Rate limiting. One practical application of this script will be slowing down the speed at which someone can download a file for free. If you pay for the service then the speed would be either unlimited or less restrictive.
Another application would be if you are generating the file as it is being created. Like, If there is a 10mb lossless image, and you know that it takes at most 1 second to create 256kb of it, then you can set the script to stream 256kb every second. This way the user can start receiving data as soon as the first 256kb are ready.
{code type=php}
// The file that will be sent to the user
$your_file = ‘file.zip’;

// Rename the file name
$new_file = ‘new-filename.zip’;

// Set the download speed limit (70 kb/s)
$download_speed = 70;

if(file_exists($myl_file) && is_file($my_file)) {

// Headers
header(‘Cache-control: private’);
header(‘Content-Type: application/octet-stream’);
header(‘Content-Length: ‘.filesize($my_file));
header(‘Content-Disposition: filename=’.$new_file);

// Flush the content
flush();

// File stream
$file = fopen($my_file, “r”);

while (!feof($file)) {

// Send the current part of the file to the browser
echo fread($file, round($download_speed* 1024));

// Flush the content to the browser
flush();

// Sleep one second
sleep(1);
}

// Close file stream
fclose($file);

}
else {
die(‘Error: The file ‘.$my_file.’ does not exist!’);
}
{/code}
This script can be used to limit the download speed at which one can download the file. You can also try out QoS Bandwidth Throttle in PHP.