<?php

/**
 * ImageManip class, for simple and common image manipulation functions
 *
 * @author Rick Hodger <rick@fuzzi.org.uk>
 * @version 1.0
 * @copyright Copyright &copy; 2006, Rick Hodger
 * @package imagemanip
 * @filesource
 */
/**
 * ImageManip class, for simple and common image manipulation functions
 * @package imagemanip
 */
class imagemanip {

    /**
     * Variable for storing the image handle.
     */
    var $image = false;
    /**
     * Defines the width in pixels of the loaded image.
     * @var integer
     */
    var $width = 0;
    /**
     * Defines the height in pixels of the loaded image.
     * @var integer
     */
    var $height = 0;
    /**
     * Contains JPEG EXIF data
     * @var array
     */
    var $exif = array();
    /**
     * Contains the type of image loaded (jpg/png)
     * @var string
     */
    var $type = '';
    /**
     * Enables/disables debugging to syslog.
     * @var bool
     */
    var $debug = true;

    function image($image='') {
        if (!empty($image)) {
            $this->load($image);
        }
    }

    /**
     * Simple debug logging function. Because of the nature of the class, it sends the debug text to syslog.
     * @access private
     */

    function debug($text) {
        if ($this->debug==true) {
            syslog(LOG_INFO,"Image Class - $text");
        }
    }

    /**
     * Load Image
     *
     * Loads your selected image into memory. Takes an optional parameter for png/jpeg identification.
     * Returns true on success, false on failure.
     *
     * $image->load("/path/to/example.jpg");
     * @param string $image
     * @param string $type
     * @return bool
     */
    function load($image,$type="") {
        if(file_exists($image)) {
            if (empty($type)) {
                $a=substr($image,strlen($image)-3);
            } else {
                $a=$type;
            }
            switch($a) {
                case "jpg":
                case "jpeg":
                    $this->image = ImageCreateFromJPEG($image);
                    $this->exif = exif_read_data($image);
                    $this->type = 'jpg';
                    break;
                case "png":
                    $this->image = ImageCreateFromPNG($image);
//                    imageAlphaBlending($this->image, false);
//                    imageSaveAlpha($this->image, true);
                    $this->type = 'png';
                    break;
            }
            $this->width = imagesx($this->image);
            $this->height = imagesy($this->image);
            $this->size = filesize($img);
            $this->watermark = false;
            return true;
        } else {
            return false;
        }
    }

    /**
     * Save Image
     *
     * Saves your image to a file. The example below uses the 'type' variable to ensure that the image is
     * saved with a filename appropriate to the filetype.
     * 
     * $image->save("/path/to/destination.".$image->type);
     * @param string $dest
     */
    function save($dest) {
        switch($this->type) {
            case "jpg":
                imagejpeg($this->image,$dest,100);
                break;
            case "png":
                imagepng($this->image,$dest);
                break;
        }
        return true;
    }

    /**
     * Smart Resize
     *
     * Smart resize. Will attempt to ensure that aspect ration is maintained on any image you resize.
     * Parts of this code have been gathered from various PHP authors, comments and so on. The example
     * given will resize a given image to fit into a 50x50 pixel box.
     * 
     * $image->resize(50,50);
     * @param integer $max_x
     * @param integer $max_y
     */
    function resize($max_x=100,$max_y=100) {
        list($fx,$fy) = $this->_calc_resize($max_x,$max_y,$this->width,$this->height);
        if ($fx <> $this->width || $fy <> $this->height) {
            $save = imagecreatetruecolor($fx,$fy);
            // hack to cope with transparent pngs
            if ($this->type==='png') {
                if(!imagealphablending($save,FALSE)){
                    return FALSE;
                }
                if(!imagesavealpha($save,TRUE)){
                    return FALSE;
                }
            }
            imagecopyresampled($save,$this->image, 0, 0, 0, 0, $fx, $fy, $this->width, $this->height);
            imagedestroy($this->image);
            $this->image=$save;
            $this->width=$fx;
            $this->height=$fy;
            return true;
        } else {
            return false;
        }
    }

    /**
     * Used by the resize() function to calculate actual pixel dimensions for an image, while maintained aspect.
     * @access private
     */
    function _calc_resize($max_x=100,$max_y=100,$width,$height) {
        if ($width > $max_x || $height > $max_y) {
            // this needs resized
            if ($max_x && ($width < $height)) {
                $fx = ($max_y / $height) * $width;
                $fy = $max_y;
            } else {
                $fy = ($max_x / $width) * $height;
                $fx = $max_x;
            }
            return array(floor($fx),floor($fy));
        }
    }

    /**
     * Output Image
     *
     * Outputs the current image directly to the web browser. Generates correct MIME header too.
     *
     * $image->output();
     */
    function output() {
        switch($this->type) {
            case 'jpg':
                Header('Content-type: image/jpeg');
                imagejpeg($this->image,false,100);
                break;
            case 'png':
                Header('Content-type: image/x-png');
                imagepng($this->image);
                break;
        }
    }

    /**
     * Watermark
     *
     * Given the path to an appropriate PNG file, will watermark the loaded image. If the PNG image contains
     * an alpha channel, that should be taken into effect providing transparency on the watermark.
     *
     * $image->watermark('/path/to/watermark.png');
     * @param string $watermark
     * @param string $pos
     */
    function watermark($watermark,$pos='center') {
        if ($this->watermark==false) {
            // create second image class to perform resize of watermark
            $tmp = new image($watermark);
            imageAlphaBlending($tmp->image, false);
            imageSaveAlpha($tmp->image, true);

            // resize watermark to half the size of the photo
            $tmp->_resize($this->width/2,$this->height/2);

            switch($pos) {
                case "bottom_right":
                    $dest_x = ( $this->width - ($tmp->width+20) );
                    $dest_y = ( $this->height - ($tmp->height+20) );
                    break;
                case "center":
                default:
                    // across the middle
                    $dest_x = ( ($this->width/2) - ($tmp->width/2) );
                    $dest_y = ( ($this->height/2) - ($tmp->height/2) );
                    break;
            }
 
            imagecopy($this->image, $tmp->image, $dest_x, $dest_y, 0, 0, $tmp->width, $tmp->height);
            $this->watermark=true;

            imagedestroy($tmp->image);
        }
    }

}
?>