<?php
/**
 * @author m4a1fox
 * @copyright 2012
 */

class DownloadFile extends Conf{
    private     $folder; // folder to dawnload file
    public      $image; 
    private     $smallWH; // size of small image W - width, H- height
    private     $smallImageName; // small image name
    private     $NewFileName; // name of normal image
    private     $imageName; // connect ext & name
    private     $extension; // ext
    private $error = array(); // error put on this array()
    
    /**
     * __construct take param 
     * $file - filename. Taken from $_FILES['input name="????"']
     * $folder - folder to download file
     * $smallWH - W - width, H- height
     */
    public function __construct($file, $folder, $smallWH = array()){
        $this->image = $file;
        $this->folder = $folder;
        $this->smallWH = $smallWH;
        $this->extension = pathinfo($this->image['name'], PATHINFO_EXTENSION);
        $this->NewFileName = $this->RandomFileName();
        $this->imageName = $this->NewFileName.'.'.$this->extension;
        $this->smallImageName = $this->NewFileName.'_s.'.$this->extension;
    }
    
    /**
     * main method to move & create of copy file
     */
    
    public function MoveImage() {
       /**
        * check for error
        */ 
        if($this->CheckForError()){
            /**
             * default function of php - move upload file
             * @param tmp file
             * @param folder & name of image
             */
                move_uploaded_file($this->image['tmp_name'], $this->folder.$this->imageName);
                /**
                 * check file ext
                 */
                if(in_array($this->image['type'], $this->allowTypeImage)){
                    /**
                     * create a link to Resize class
                     * @param file
                     */
                    $this->resize = new Resize($this->folder.$this->imageName);
                    /**
                     * copy file.
                     * @param Width (from Conf class)
                     * @param Height (from Conf class)
                     * @param Some other option (from Conf class)
                     * @param Path to default file
                     * @param choose quality of the dcreaten file 
                     */
                    $this->MakeCopy($this->imageW, $this->imageH, $this->option, $this->folder.$this->imageName, $this->quality);
                    /**
                     * insert in array the path to big image
                     */
                    $ar['image'] = $this->folder.$this->imageName;
                    /**
                     * if in __construct() isset array() of width & height small image - create it
                     */
                    if(count($this->smallWH)){
                        $this->MakeCopy($this->smallWH[0], $this->smallWH[1], $this->option, $this->folder.$this->smallImageName, $this->quality);
                    /**
                     * insert in array the path to small image
                     */
                        $ar['small_image'] = $this->folder.$this->smallImageName;
                    }
                    /**
                     * return array with paths of big & small image
                     */
                    return $ar;   
                }
                /**
                 * return path to big image
                 */
                return $this->folder.$this->imageName;
        }else{
            /**
             * else, return error
             */
            return $this->error;
        }
    }
    
    /**
     * function check for error
     * if error is - put the error in array()
     */
    private function CheckForError(){
        if(!is_uploaded_file($this->image['tmp_name'])){
            $this->error['file'] = 'You must load the file';
            return FALSE;
        }elseif(!in_array($this->image['type'], $this->allowTypeImage) && !in_array($this->image['type'], $this->allowTypeAudio)){
            $this->error['type'] = 'Uncorrect type image';
            return FALSE;
        }
        return TRUE;
    }  
    
    /**
     * function to copy file from tmp folder -> uor folder
     */
    private function MakeCopy($width, $height, $option, $folder, $quality){
        /**
         * take the function from the Resize class
         * @param width
         * @param height
         * @param option
         */
        $this->resize->resizeImage($width, $height, $option);
        /**
         * take the function from the Resize class
         * @param folder
         * @param quality
         */   
        $this->resize->saveImage($folder, $quality);
    }
    
    /**
     * if name file not on english, function translate it
     */
    public function TranslitFileName()
	{
	$trans = array(
		"А"=>"a","Б"=>"b","В"=>"v","Г"=>"g",
        "Д"=>"d","Е"=>"e","Ж"=>"j","З"=>"z","И"=>"i",
        "Й"=>"y","К"=>"k","Л"=>"l","М"=>"m","Н"=>"n",
        "О"=>"o","П"=>"p","Р"=>"r","С"=>"s","Т"=>"t",
        "У"=>"u","Ф"=>"f","Х"=>"h","Ц"=>"ts","Ч"=>"ch",
        "Ш"=>"sh","Щ"=>"sch","Ъ"=>"","Ы"=>"yi","Ь"=>"",
        "Э"=>"e","Ю"=>"yu","Я"=>"ya","а"=>"a","б"=>"b",
        "в"=>"v","г"=>"g","д"=>"d","е"=>"e","ж"=>"j",
        "з"=>"z","и"=>"i","й"=>"y","к"=>"k","л"=>"l",
        "м"=>"m","н"=>"n","о"=>"o","п"=>"p","р"=>"r",
        "с"=>"s","т"=>"t","у"=>"u","ф"=>"f","х"=>"h",
        "ц"=>"ts","ч"=>"ch","ш"=>"sh","щ"=>"sch","ъ"=>"y",
        "ы"=>"yi","ь"=>"","э"=>"e","ю"=>"yu","я"=>"ya", 
        " "=> "_", "/"=> "_"
		);
	  return strtr(pathinfo($this->image['name'], PATHINFO_FILENAME), $trans).time();
	}
    
    /**
     * random name of file
     */
    private function RandomFileName(){
        /**
         * var abc taken from the Conf class
         */
        return substr(str_shuffle($this->abc), 0, 10);
    }  
}

<?php

/**
 * Resize class image
 * @author admin
 * @copyright 2011
 */  
class Resize extends Conf{
    
    /**
    * @var $image 
    * @var $width
    * @var $height
    */
    
    public  $file;
    private $image;
    private $width;
    private $height;
    private $imageResized;
    public $watermark;
    public $watermarkWidth;
    public $watermarkHeight;
    //public $watermarkPosition = 'bottom_center';
    
    public function __construct($fileName){
        $this->file = $fileName;
        // Open file
        $this->image = $this->openImage($fileName);
        // default parameters: width&height
        $this->width = imagesx($this->image);
        $this->height = imagesy($this->image);
        if($this->watermarDo){
            if(file_exists($this->watermarkFilePath)){
            $this->watermark = imagecreatefrompng($this->watermarkFilePath);
            $this->watermarkWidth = imagesx($this->watermark);
            $this->watermarkHeight = imagesy($this->watermark);
            }else{
                throw new Exception("Watermark doesn't exist");
            }
        }
        
    }
    
    private function openImage($file){
        $extension = strtolower(strrchr($file, '.'));
        
        switch($extension){
            case '.jpg':
            case '.jpeg':
                $image = @imagecreatefromjpeg($file);
            break;
            case '.gif':
                $image = @imagecreatefromgif($file);
            break;
            case '.png':
                $image = imagecreatefrompng($file);
            break;
            default:
                $image = false;
            break;
        }
        return $image;
    }
    
    public function watermarkPosition(){
        
        $x = array(10, $this->width/2, $this->width - $this->watermarkWidth - 10);
        $y = array(10, $this->height/2, $this->height - $this->watermarkHeight - 10);
        
        switch($this->watermarkPosition){
            case('top_center'):
                $posX = $x[1];
                $posY = $y[0];
                break;
            case('top_right'):
                $posX = $x[2];
                $posY = $y[0];
                break;
            case('middle_left'):
                $posX = $x[0];
                $posY = $y[1];
                break;
            case('middle_center'):
                $posX = $x[1];
                $posY = $y[1];
                break;
            case('middle_right'):
                $posX = $x[2];
                $posY = $y[1];
                break;
            case('bottom_left'):
                $posX = $x[0];
                $posY = $y[2];
                break;
            case('bottom_center'):
                $posX = $x[1];
                $posY = $y[2];
                break;
            case('bottom_right'):
                $posX = $x[2];
                $posY = $y[2];
                break;
            default :
                $posX = 10;
                $posY = 10;
        }
        return array('x'=>$posX, 'y'=>$posY);
    }
    
    
    
    public function resizeImage($newWidth, $newHeight, $option = 'auto'){
        if($this->watermarDo){
            $position = $this->watermarkPosition();
            imagecopy($this->image, $this->watermark, $position['x'], $position['y'], 0, 0, $this->watermarkWidth, $this->watermarkHeight);
        }
        $optionArray = $this->getDimension($newWidth, $newHeight, strtolower($option));
        
        $optimalWidth = $optionArray['optimalWidth'];
        $optimalHeight = $optionArray['optimalHeight'];
        
        $this->imageResized = imagecreatetruecolor($optimalWidth, $optimalHeight);
        imagecopyresampled($this->imageResized, $this->image, 0, 0, 0, 0, $optimalWidth, $optimalHeight, $this->width, $this->height);
        
        
        
        if($option == 'crop'){
            $this->crop($optimalWidth, $optimalHeight, $newWidth, $newHeight);
        }
    }
     
    private function getDimension($newWidth, $newHeight, $option){
        switch($option){
            case 'exact':
                $optimalWidth = $newWidth;
                $optimalHeight = $newHeight;
            break;
            case 'portrain':
                $optimalWidth = $this->getSizeByFixedHeight($newHeight);
                $optimalHeight = $newHeight;
            break;
            case 'landscape':
                $optimalWidth = $newWidth;
                $optimalHeight = $this->getSizeByFixedWidth($newWidth);
            break;
            case 'auto':
                $optionArray = $this->getSizeByAuto($newWidth, $newHeight);
                $optimalWidth = $optionArray['optimalWidth'];
                $optimalHeight = $optionArray['optimalHeight'];
            break;
            case 'crop' :
                $optionArray = $this->getOptimalCrop($newWidth, $newHeight);
                $optimalWidth = $optionArray['optimalWidth'];
                $optimalHeight = $optionArray['optimalHeight'];
        }
        return array('optimalWidth' => $optimalWidth, 'optimalHeight' => $optimalHeight);
    }
    
    private function getSizeByFixedHeight($newHeight){
        $ration = $this->width/$this->height;
        $newWidth = $newHeight * $ration;
        return $newWidth;
    }
    
    private function getSizeByFixedWidth($newWidth){
        $ratio = $this->height / $this->width;
        $newHeight = $newWidth * $ratio;
        return $newHeight;
    }
    
    private function getSizeByAuto($newWidth, $newHeight){
        // Change image by width (landscape)
        if($this->height < $this->width){
            $optimalWidth = $newWidth;
            $optimalHeight = $this->getSizeByFixedWidth($newWidth);
        }elseif($this->height > $this->width){ // Image change by height (portrait)
            $optimalWidth = $this->getSizeByFixedHeight($newHeight);
            $optimalHeight = $newHeight;
        }else{ // Change image with the specificed values 
            if($newHeight < $newWidth){
                $optimalWidth = $newWidth;
                $optimalHeight = $this->getSizeByFixedWidth($newWidth);
            }elseif($newHeight > $newWidth){
                $optimalWidth = $this->getSizeByFixedHeight($newHeight);
                $optimalHeight = $newHeight;
            }else{
                $optimalWidth = $newWidth;
                $optimalHeight = $newHeight;
            }
        }
        return array('optimalWidth' => $optimalWidth, 'optimalHeight' => $optimalHeight);
    }
    
    private function getOptimalCrop($newWidth, $newHeight){
        $widthRation = $this->width / $newWidth;
        $heightRation = $this->height / $newHeight;
      
        if($heightRation < $widthRation){
            $optimalRatio = $heightRation;
        }else{
            $optimalRatio = $widthRation;
        }
        
        $optimalWidth = $this->width / $optimalRatio;
        $optimalHeight = $this->height / $optimalRatio;
        
        return array('optimalWidth' => $optimalWidth, 'optimalHeight' => $optimalHeight);
    }
    
    private function crop($optimalWidth, $optimalHeight, $newWidth, $newHeight){
        // Search of center image for resize
        $cropStartX = ($optimalWidth/2) - ($newWidth/2);
        $cropStartY = ($optimalHeight/2) - ($newHeight/2);
        
        $crop = $this->imageResized;
        
        // cut a piece of the specified image
        $this->imageResized = imagecreatetruecolor($newWidth, $newHeight);
        imagecopyresampled($this->imageResized, $crop, 0, 0, $cropStartX, $cropStartX, $newWidth, $newHeight, $newWidth, $newHeight);
    }
    
    public function saveImage($savePath, $imageQulity = '100'){
        // Get extension
        $extension = strrchr($savePath, '.');
        $extension = strtolower($extension);

        switch($extension){
            case '.jpg':
            case '.jpeg':
                if(imagetypes() & IMG_JPG){
                    imagejpeg($this->imageResized, $savePath);
                }
            break;
            
            case '.gif':
                if(imagetypes() & IMG_GIF){
                    imagegif($this->imageResized, $savePath);
                }
            break;
            
            case '.png':
                // Quality rand 0-100 -> 0-9
                $scaleQuality = round(($imageQulity/100)*9);
                
                // Invert quality 0 -> best
                $invertScaleQuality = 9-$scaleQuality;
                
                if(imagetypes() & IMG_PNG){
                    imagepng($this->imageResized, $savePath, $invertScaleQuality);
                }
            break;
            
            default:
                break;
        }
        imagedestroy($this->imageResized);
    }  
 }

<?php
/**
 * @author m4a1fox
 * @date 10.03.2012 
 */

abstract class Conf{ 
    
    /**
     * 
     * @var int
     * @desc quality of download image file
     * @param $quality - Accepted values: 1-100
     * 
     */
    protected $quality = 100;
    
    /**
     * 
     * @var str
     * @desc what type of resize will be
     * Accepted values:
     *      auto - default ()
     * @TODO - write other needed option of changing size of file-image
     * 
     * 
     * 
     * @param $option
     * 
     */
    protected $option = 'auto';
    
    /**
     * 
     * @var int
     * @desc What width of original image will be
     * @param $imageW - Accepted values: all interger. default eq.700.
     * 
     */
    protected $imageW = 700;
    
    /**
     * 
     * @var type int
     * @desc What height of original image will be
     * @param $imageH - Accepted values: all interger. default eq.500.
     * 
     */
    protected $imageH = 500;
    
    /**
     * 
     * @var array
     * @desc What allowed type of image file can dowload on the server.
     * @param $allowTypeImage - Accepted values: array('image/jpeg', 'image/jpg', 'image/png', 'image/gif').
     * 
     */
    protected $allowTypeImage = array('image/jpeg', 'image/jpg', 'image/png', 'image/gif');
    
    /**
     * 
     * @var array
     * @desc What allowed type of mp3 file can dowload on the server.
     * @param $allowTypeImage - Accepted values: array('audio/mpeg', 'audio/mp3').
     * 
     */
    protected $allowTypeAudio = array('audio/mpeg', 'audio/mp3');
    
    /**
     * 
     * @var str
     * @desc From what letter will be create name of download file
     * @param $abc - Accepted values: 'abcdefghijklmnopqrstuvwxyzABSCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'.
     * 
     */
    protected $abc = 'abcdefghijklmnopqrstuvwxyzABSCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
    
    /**
     *
     * @var str
     * @desc path to the watermark file
     * @param  $watermarkFilePath - Accepted values: './file/watermark.png'.
     *  
     */
    protected $watermarkFilePath = '';
    
    /**
     * 
     * @var bollean
     * @desc Switch watermark on the file
     * @param $watermarDo - Accepted values: TRUE || FALSE. default - TRUE 
     */
    protected $watermarDo = FALSE;
        
    /**
     * 
     * @var str
     * @desc What watermark position will be on the file.
     * @desc Leave the var empty, and the value will be - default(left_top).
     * @param $watermarkPosition - Accepted values: top_left(default), top_center, top_right, middle_left, middle_center, middle_right, 
     * bottom_left, bottom_center, bottom_right.
     * 
     */
    protected $watermarkPosition = 'bottom_left';
}

 $this->imageName = $this->NewFileName.'.'.$this->extension;