[PHP 5.1] PHOTOPHOP (PHPDRAW 2)

<?php
/**
PHOTOPHOP (PHPDRAW 2)
Copyright (C) 2007  Johan Barbier <johan.barbier@gmail.com>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
/**
 * Notre INTERFACE EXPRESSION
 *
 */
interface expression {
	public static function interpret(interpreter $subject, $mParam);
}

/**
 * Une EXPRESSION CONCRETE pour la création d'une ligne
 *
 */
class line implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(false === strpos($mParam, '-')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid parameter '.$mParam);
		}
		$aParam = explode('-', $mParam);
		$iX = (int)$aParam[0];
		$iY = (int)$aParam[1];		
		if (false === imageline($subject->IMG, $subject->X, $subject->Y, $iX, $iY, $subject->RCOLOR)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create ellipse');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour la création d'une ellipse
 *
 */
class ellipse implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(false === strpos($mParam, '-')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid parameter '.$mParam);
		}
		$aParam = explode('-', $mParam);
		$iWidth = (int)$aParam[0];
		$iHeight = (int)$aParam[1];		
		if (false === imageellipse($subject->IMG, $subject->X, $subject->Y, $iWidth, $iHeight, $subject->RCOLOR)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create ellipse');
		}
	}	
}

/**
* Une EXPRESSION CONCRETE pour la création d'une ellipse remplie
*
*/
class filledellipse implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(false === strpos($mParam, '-')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid parameter '.$mParam);
		}
		$aParam = explode('-', $mParam);
		$iWidth = (int)$aParam[0];
		$iHeight = (int)$aParam[1];
		if($subject->TILE === 'none') {
			if (false === imagefilledellipse($subject->IMG, $subject->X, $subject->Y, $iWidth, $iHeight, $subject->RCOLOR)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create filled ellipse');
			}
		} else {
			$rTile = miscImgSetter::set($subject->TILE);
			if(false === imagesettile($subject->IMG, $rTile)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to set tile');
			}
			if (false === imagefilledellipse($subject->IMG, $subject->X, $subject->Y, $iWidth, $iHeight, IMG_COLOR_TILED)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to fill ellipse with tiles');
			}
		}
	}
}

/**
* Une EXPRESSION CONCRETE pour la création d'un arc remplis
*
*/
class filledarc implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(false === strpos($mParam, '-')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid parameter '.$mParam);
		}
		$aParam = explode('-', $mParam);
		$iWidth = (int)$aParam[0];
		$iHeight = (int)$aParam[1];
		$iStart = (int)$aParam[2];
		$iEnd = (int)$aParam[3];
		if (false === imagefilledarc($subject->IMG, $subject->X, $subject->Y, $iWidth, $iHeight, $iStart, $iEnd, $subject->RCOLOR, IMG_ARC_PIE)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create filled arc');
		}
	}
}

/**
 * Une EXPRESSION CONCRETE pour la création d'un rectangle
 *
 */
class rectangle implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(false === strpos($mParam, '-')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid parameter '.$mParam);
		}
		$aParam = explode('-', $mParam);
		$iX = (int)$aParam[0];
		$iY = (int)$aParam[1];		
		if (false === imagerectangle($subject->IMG, $subject->X, $subject->Y, $iX, $iY, $subject->RCOLOR)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create rectangle');
		}
	}	
}

/**
* Une EXPRESSION CONCRETE pour la création d'une ellipse remplie
*
*/
class filledrectangle implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(false === strpos($mParam, '-')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid parameter '.$mParam);
		}
		$aParam = explode('-', $mParam);
		$iX = (int)$aParam[0];
		$iY = (int)$aParam[1];
		if($subject->TILE === 'none') {
			if (false === imagefilledrectangle($subject->IMG, $subject->X, $subject->Y, $iX, $iY, $subject->RCOLOR)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create filled rectangle');
			}
		} else {
			$rTile = miscImgSetter::set($subject->TILE);
			if(false === imagesettile($subject->IMG, $rTile)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to set tile');
			}
			if (false === imagefilledrectangle($subject->IMG, $subject->X, $subject->Y, $iX, $iY, IMG_COLOR_TILED)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to fill rectangle with tiles');
			}
		}
	}
}

/**
 * Une EXPRESSION CONCRETE pour la création d'un polygone
 *
 */
class polygon implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(false === strpos($mParam, '-')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid parameter '.$mParam);
		}
		$aParam = array_map ('intval', explode('-', $mParam));
		$iCount = count($aParam);
		if(0 !== $iCount%2) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : total points must be even : '.$iCount);
		}
		$iCount /= 2;
		if (false === imagepolygon($subject->IMG, $aParam, $iCount, $subject->RCOLOR)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create polygon');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour la couleur du trait
 *
 */
class color implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!is_numeric($mParam) || 9 !== strlen($mParam)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid color '.$mParam);
		}
		$iRed = (int)substr($mParam, 0, 3);
		$iGreen = (int)substr($mParam, 3, 3);
		$iBlue = (int)substr($mParam, 6, 3);
		$subject->RCOLOR = imagecolorallocate($subject->IMG, $iRed, $iGreen, $iBlue);
		$subject->SCOLOR = $mParam;
		if(false === $subject->RCOLOR) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to allocate color '.$mParam);
		}
	}	
}

/**
* Une EXPRESSION CONCRETE pour remplir l'image ou une sélection avec la couleur courante
*
*/
class fill implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if($mParam !== '0') {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid parameter '.$mParam);
		}
		if($subject->TILE === 'none') {
			if (false === imagefill($subject->IMG, 0, 0, $subject->RCOLOR)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to fill image');
			}
		} else {
			$rTile = miscImgSetter::set($subject->TILE);
			if(false === imagesettile($subject->IMG, $rTile)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to set tile');
			}
			if (false === imagefill($subject->IMG, 0, 0, IMG_COLOR_TILED)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to fill image with tiles');
			}
		}
	}
}

/**
 * Une EXPRESSION CONCRETE pour l'épaisseur du trait
 *
 */
class pixel implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!is_numeric($mParam)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid position '.$mParam);
		}
		$mParam = (int)$mParam;
		if (false === imagesetthickness($subject->IMG, $mParam)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to set thickness '.$mParam);
		}
		$subject->SPIXEL = $mParam;
	}	
}

/**
 * Une EXPRESSION CONCRETE pour initialiser la taille de la police de caractère (1-5)
 *
 */
class fontsize implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!is_numeric($mParam) || $mParam < 1 || $mParam > 5) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid font size '.$mParam);
		}
		$mParam = (int)$mParam;
		$subject->FONTSIZE = $mParam;
	}	
}

/**
 * Une EXPRESSION CONCRETE pour appliquer un flou gaussien à l'image
 *
 */
class gaussianblur implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid gaussianblur call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_GAUSSIAN_BLUR)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to apply gaussian blur to the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour appliquer un flou sélectif à l'image
 *
 */
class selectiveblur implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid selective call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_SELECTIVE_BLUR)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to apply selective blur to the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour appliquer un filtre mettant en évidence les bords de l'image
 *
 */
class edgedetect implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid selective call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_EDGEDETECT)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to apply selective blur to the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour appliquer un effet de mouvement à l'image la rendant "imprécise
 *
 */
class meanremoval implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid mean removal call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_MEAN_REMOVAL)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to apply mean removal to the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour appliquer un effet de relief à l'image
 *
 */
class emboss implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid emboss call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_EMBOSS)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to apply emboss to the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour transformer l'image en nuances de gris
 *
 */
class greyscale implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid greyscale call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_GRAYSCALE)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to gray scale the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour transformer l'image en son négatif
 *
 */
class negate implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid negate call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_NEGATE)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to negate the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour coloriser l'image
 *
 */
class colorize implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid colorize call '.$mParam);
		}
		$aColors = str_split($subject->SCOLOR, 3);
		if(false === imagefilter($subject->IMG, IMG_FILTER_COLORIZE, $aColors[0], $aColors[1], $aColors[2])) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to colorize the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour coloriser l'image en sepia
 *
 */
class sepia implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid sepia call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_GRAYSCALE) || false === imagefilter($subject->IMG, IMG_FILTER_COLORIZE, 90, 60, 40)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to sepia the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour lisser l'image
 *
 */
class smooth implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		$mparam = (float)$mParam;
		if($mParam < -1924 || $mParam > 2048) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid smooth call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_SMOOTH, $mParam)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to smoothe the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour règler l'éclairage l'image
 *
 */
class brightness implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!is_numeric($mParam) || $mParam < -255 || $mParam > 255) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid brightness call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_BRIGHTNESS, $mParam)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to bright the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour régler le contraste l'image
 *
 */
class contrast implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!is_numeric($mParam) || $mParam < -100 || $mParam > 100) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid contrast call '.$mParam);
		}
		if(false === imagefilter($subject->IMG, IMG_FILTER_CONTRAST, -$mParam)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to contrast the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour la rotation de l'image
 *
 */
class rotate implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		$mParam = (float)$mParam;
		if($mParam < -360 || $mParam > 360) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid rotate call '.$mParam);
		}
		if(false === ($subject->IMG = imagerotate($subject->IMG, $mParam, $subject->RCOLOR))) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to rotate the image');
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour le redimensionnement d'une image
 *
 */
class resize implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(false === strpos($mParam, '-')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid resize parameter '.$mParam);
		}
		$aParam = explode('-', $mParam);
		$iWidth = (int)$aParam[0];
		$iHeight = (int)$aParam[1];
		$rDestImg = imagecreatetruecolor($iWidth, $iHeight);
		if(false === (imagecopyresampled($rDestImg, $subject->IMG, 0, 0, 0, 0, $iWidth, $iHeight, $subject->WIDTH, $subject->HEIGHT))) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to resize the image');
		}
		$subject->IMG = $rDestImg;
	}	
}

/**
 * Une EXPRESSION CONCRETE pour le rognage d'une image
 *
 */
class crop implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(false === strpos($mParam, '-')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid resize parameter '.$mParam);
		}
		$aParam = explode('-', $mParam);
		$iX = (int)$aParam[0];
		$iY = (int)$aParam[1];
		$iWidth =  abs($subject->X - $iX );
		$iHeight =  abs($subject->Y - $iY );
		if($subject->X <= $iX) {
			$iXSRC = $subject->X;
		} else {
			$iXSRC = $iX;
		}
		if($subject->Y <= $iY) {
			$iYSRC = $subject->Y;
		} else {
			$iYSRC = $iY;
		}
		$rDestImg = imagecreatetruecolor($iWidth, $iHeight);
		if(false === (imagecopy($rDestImg, $subject->IMG, 0, 0, $iXSRC, $iYSRC, $iWidth, $iHeight))) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to resize the image');
		}
		$subject->IMG = $rDestImg;
	}	
}

/**
 * Une EXPRESSION CONCRETE pour appliquer un filtre "ondulations" à l'image
 * Algorithm for wavy stuff from Kruglov Sergei : http://www.phpclasses.org/browse/package/3193.html
 * Might take some time to complete...
 *
 */
class wavy implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid wavy call '.$mParam);
		}
		
		$foreground_color = array(mt_rand(0,100), mt_rand(0,100), mt_rand(0,100));
		$background_color = array(mt_rand(200,255), mt_rand(200,255), mt_rand(200,255)); 
		$foreground = imagecolorallocate($subject->IMG, $foreground_color[0], $foreground_color[1], $foreground_color[2]);
		$background = imagecolorallocate($subject->IMG, $background_color[0], $background_color[1], $background_color[2]);

		$rand1=mt_rand(400000,1000000)/10000000;
		$rand2=mt_rand(400000,1000000)/10000000;
		$rand3=mt_rand(400000,1000000)/10000000;
		$rand4=mt_rand(400000,1000000)/10000000;
		// phases
		$rand5=mt_rand(0,3141592)/500000;
		$rand6=mt_rand(0,3141592)/500000;
		$rand7=mt_rand(0,3141592)/500000;
		$rand8=mt_rand(0,3141592)/500000;
		// amplitudes
		$rand9=mt_rand(330,420)/110;
		$rand10=mt_rand(330,450)/110; 
		$iWidth = imagesx($subject->IMG);
		$iHeight = imagesy($subject->IMG);
		for($x=0;$x<$iWidth;$x++){
			for($y=0;$y<$iHeight;$y++){
				$sx=$x+(sin($x*$rand1+$rand5)+sin($y*$rand3+$rand6))*$rand9-$iWidth/2+($iWidth/2)+1;
				$sy=$y+(sin($x*$rand2+$rand7)+sin($y*$rand4+$rand8))*$rand10;
				
				if($sx<0 || $sy<0 || $sx>=$iWidth-1 || $sy>=$iHeight-1){
					$color=255;
					$color_x=255;
					$color_y=255;
					$color_xy=255;
				}else{
					$color=imagecolorat($subject->IMG, $sx, $sy) & 0xFF;
					$color_x=imagecolorat($subject->IMG, $sx+1, $sy) & 0xFF;
					$color_y=imagecolorat($subject->IMG, $sx, $sy+1) & 0xFF;
					$color_xy=imagecolorat($subject->IMG, $sx+1, $sy+1) & 0xFF;
				}
					
				if($color==0 && $color_x==0 && $color_y==0 && $color_xy==0){
					$newred=$foreground_color[0];
					$newgreen=$foreground_color[1];
					$newblue=$foreground_color[2];
				}else if($color==255 && $color_x==255 && $color_y==255 && $color_xy==255){
					$newred=$background_color[0];
					$newgreen=$background_color[1];
					$newblue=$background_color[2];
				}else{
					$frsx=$sx-floor($sx);
					$frsy=$sy-floor($sy);
					$frsx1=1-$frsx;
					$frsy1=1-$frsy;
					
					$newcolor=(
					$color*$frsx1*$frsy1+
					$color_x*$frsx*$frsy1+
					$color_y*$frsx1*$frsy+
					$color_xy*$frsx*$frsy);
					
					if($newcolor>255)  {
						$newcolor=255;
					}
					$newcolor=$newcolor/255;
					$newcolor0=1-$newcolor;
					
					
					$newred=$newcolor0*$foreground_color[0]+$newcolor*$background_color[0];
					$newgreen=$newcolor0*$foreground_color[1]+$newcolor*$background_color[1];
					$newblue=$newcolor0*$foreground_color[2]+$newcolor*$background_color[2];
				}
			
				if(false === imagesetpixel($subject->IMG, $x, $y, imagecolorallocate($subject->IMG, $newred, $newgreen, $newblue))) {
					throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to apply wavy to the image');
				}
			}
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour transformer l'image en noir et blanc
 *
 */
class blackwhite implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!ctype_digit($mParam) || (int)$mParam !== 0) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid black and white call '.$mParam);
		}
		if(imageistruecolor($subject->IMG)) {
			if (false === imagetruecolortopalette($subject->IMG, false, 256)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to get true color to palette');
		    }
		}
	    for ($iC = 0; $iC < imagecolorstotal($subject->IMG); $iC++) {
	        $aCol = imagecolorsforindex($subject->IMG, $iC);
	        array_pop($aCol);
	        $iColor = (array_sum($aCol) > 383)?255:0;
	        imagecolorset($subject->IMG, $iC, $iColor, $iColor, $iColor);
	    }
	}	
}

/**
 * Une EXPRESSION CONCRETE pour l'écriture d'un texte horizontal
 *
 */
class text implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(0 !== strpos($mParam, '"') || (strlen($mParam) - 1) !== strrpos($mParam, '"')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid text value '.$mParam);
		}
		$mParam = trim($mParam, '"');
		if (false === imagestring($subject->IMG, $subject->FONTSIZE, $subject->X, $subject->Y, $mParam, $subject->RCOLOR)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to write text '.$mParam);
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour l'écriture d'un texte vertical
 *
 */
class textV implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(0 !== strpos($mParam, '"') || (strlen($mParam) - 1) !== strrpos($mParam, '"')) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid text value '.$mParam);
		}
		$mParam = trim($mParam, '"');
		if (false === imagestringup($subject->IMG, $subject->FONTSIZE, $subject->X, $subject->Y, $mParam, $subject->RCOLOR)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to write text '.$mParam);
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour la sauvegarde de l'image sous un nom particulier
 *
 */
class file implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		if(!is_string($mParam)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid filename '.$mParam);
		}
		if(defined('PATH_SAVE') && is_dir(PATH_SAVE)) {
			$sSavedPath = PATH_SAVE;
		} else {
			$sSavedPath = '../saved/';
		}
		if(!is_dir($sSavedPath)) {
			mkdir($sSavedPath, 0755);
		}
		$sType = substr($mParam, strrpos($mParam, '.') + 1);
		switch($sType) {
			case 'png': 
				$sFunction = create_function('$rImg, $sFile', 'return imagepng($rImg, $sFile);');
				break;
			case 'jpeg': 
				$sFunction = create_function('$rImg, $sFile', 'return imagejpeg($rImg, $sFile);');
				break;
			case 'gif': 
				$sFunction = create_function('$rImg, $sFile', 'return imagegif($rImg, $sFile);');
				break;
			default:
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to save image to file '.$mParam);
				break;
		}
		if (false === $sFunction($subject->IMG, $sSavedPath.$mParam)) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to save image to file '.$mParam);
		}
	}	
}

/**
 * Une EXPRESSION CONCRETE pour annuler la dernière action
 *
 */
class undo implements expression {
	public static function interpret(interpreter $subject, $mParam) {
		$storer = new SplImageMemento('../stored');
		$rImg = $storer->pop();
		if(is_resource($rImg) && get_resource_type($rImg) === 'gd') {
			$subject->IMG = $rImg;
		}
	}	
}

/**
* A static class used to retrieve misc images (such as tiles images)
*
*/
class miscImgSetter {
	public static function set($sFileName) {
		if(false === ($aProps = getimagesize('../'.$sFileName))) {
			throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to retrieve image '.$sFileName);
		}
		switch($aProps[2]) {
			case IMAGETYPE_PNG:
				$sUserFunc = 'imagecreatefrompng';
				break;
			case IMAGETYPE_JPEG:
				$sUserFunc = 'imagecreatefromjpeg';
				break;
			case IMAGETYPE_GIF:
				$sUserFunc = 'imagecreatefromgif';
				break;
			default:
				throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : '.$sFileName.' is not a valid image type');
		}
		$rMiscImg = $sUserFunc('../'.$sFileName);
		if(false === $rMiscImg) {
			throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : Failed to retrieve image '.$sFileName);
		}
		return $rMiscImg;
	}
}

/**
 * Notre INTERPRETER
 *
 */
class interpreter {
	private $iX = 200;
	private $iY = 200;
	private $sColor;
	private $iWidth = 500;
	private $iHeight = 500;
	private $iThickNess = 1;
	private $iFontSize = 1;
	private $aDefaultDim = array(500,500);
	private $oExpressionStack;
	private $imh;
	private $colorh;
	private $sSelectionPos;
	private $rStoredImage;
	private $sTile = 'none';
	
	private $aCor = array(
		'X' => array('cor' => 'iX', 'type' => 'is_int', 'gettable' => true, 'settable' => true),
		'Y' => array('cor' => 'iY', 'type' => 'is_int', 'gettable' => true, 'settable' => true),
		'COLOR' => array('cor' => 'sColor', 'type' => 'is_string', 'gettable' => true, 'settable' => true),
		'SCOLOR' => array('cor' => 'sColor', 'type' => 'is_string', 'gettable' => true, 'settable' => true),
		'RCOLOR' => array('cor' => 'colorh', 'type' => 'is_int', 'gettable' => true, 'settable' => true),
		'WIDTH' => array('cor' => 'iWidth', 'type' => 'is_int', 'gettable' => true, 'settable' => true),
		'HEIGHT' => array('cor' => 'iHeight', 'type' => 'is_int', 'gettable' => true, 'settable' => true),
		'PIXEL' => array('cor' => 'iThickNess', 'type' => 'is_int', 'gettable' => true, 'settable' => true),
		'FONTSIZE' => array('cor' => 'iFontSize', 'type' => 'is_int', 'gettable' => true, 'settable' => true),
		'SPIXEL' => array('cor' => 'iThickNess', 'type' => 'is_int', 'gettable' => true, 'settable' => true),
		'IMG' => array('cor' => 'imh', 'type' => 'is_resource', 'gettable' => true, 'settable' => true),
		'SELECTION' => array('cor' => 'sSelectionPos', 'type' => 'is_string', 'gettable' => true, 'settable' => true),
		'TILE' => array('cor' => 'sTile', 'type' => 'is_string', 'gettable' => true, 'settable' => true)
	);
	
	public function __construct($sFile = null, $aNewImgOptions = null) {
		if(!is_null($sFile)) {
			$aProps = getimagesize($sFile);
			switch($aProps[2]) {
				case IMAGETYPE_PNG:
					$sUserFunc = 'imagecreatefrompng';
					break;
				case IMAGETYPE_JPEG:
					$sUserFunc = 'imagecreatefromjpeg';
					break;
				case IMAGETYPE_GIF:
					$sUserFunc = 'imagecreatefromgif';
					break;
				default:
					throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : '.$sFile.' is not a valid image type');
					break;
			}
			$this->imh = @$sUserFunc($sFile);
			if(!$this->imh) {
				throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : '.$sFile.' could not be opened an image');
			}
		} elseif(!is_null($aNewImgOptions)) {
			if(!isset($aNewImgOptions['HEIGHT']) || !isset($aNewImgOptions['WIDTH']) || !isset($aNewImgOptions['BGCOLOR'])) {
				throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : Options to create a new image are wrong');
			}
			$aColors = str_split($aNewImgOptions['BGCOLOR'], 3);
			$this->imh = imagecreatetruecolor((int)$aNewImgOptions['WIDTH'], (int)$aNewImgOptions['HEIGHT']);
			$sBackGround = imagecolorallocate($this->imh, (int)$aColors[0], (int)$aColors[1], (int)$aColors[2]);
			imagefill($this->imh, 0, 0, $sBackGround);
		} else {
			$this->imh = imagecreatetruecolor($this->iWidth, $this->iHeight);
			$sBackGround = imagecolorallocate($this->imh, 0, 0, 0);
			imagefill($this->imh, 0, 0, $sBackGround);
		} 
		$this->iWidth = imagesx($this->imh);
		$this->iHeight = imagesy($this->imh);
	}
	
	public function interpret ($sChaine) {
		if(!is_string($sChaine)) {
			throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : Parameter must be a string');
		}
		$this->oExpressionStack = new ArrayIterator(preg_split('`("[^"]+")|[\s]+`', $sChaine, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE));
		$this->evaluate();
	}
	
	private function evaluate() {
		while($this->oExpressionStack->valid()) {
			$sToken = $this->oExpressionStack->current();
			if(!class_exists($sToken)) {
				throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid expression '.$sToken);
			}
			if($sToken !== 'undo') {
				$storer = new SplImageMemento('../stored');
				$storer->attach($this->imh);
			}
			if(!empty($this->sSelectionPos)) {
				$aSelectionPos = explode('-', $this->sSelectionPos);
				if(count($aSelectionPos) !== 4) {
					throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : selection position is invalid : '.$this->sSelectionPos);
				}
				$this->rStoredImage = $this->imh;
				$this->iWidth = abs($aSelectionPos[0] - $aSelectionPos[2]);
				$this->iHeight = abs($aSelectionPos[1] - $aSelectionPos[3]);
				$this->iX = $this->iX - min($aSelectionPos[0], $aSelectionPos[2]);
				$this->iY = $this->iY - min($aSelectionPos[1], $aSelectionPos[3]);
				$this->imh = imagecreatetruecolor($this->iWidth, $this->iHeight);
				imagecopyresampled($this->imh, $this->rStoredImage, 0, 0, min($aSelectionPos[0], $aSelectionPos[2]), min($aSelectionPos[1], $aSelectionPos[3]), $this->iWidth, $this->iHeight, $this->iWidth, $this->iHeight);
			}
			$this->oExpressionStack->next();
			$mParam = $this->oExpressionStack->current();
			$interpreter = new ReflectionMethod($sToken, 'interpret');
			$interpreter->invoke(null, $this, $mParam);
			$this->oExpressionStack->next();
			if(!is_null($this->rStoredImage)) {
				imagecopy($this->rStoredImage, $this->imh ,  min($aSelectionPos[0], $aSelectionPos[2]), min($aSelectionPos[1], $aSelectionPos[3]), 0, 0, $this->iWidth, $this->iHeight);
				$this->imh = $this->rStoredImage;
			}
		}
	}
	
	public function getSavedMove($sFile) {
		if(!imagepng($this->imh, $sFile)) {
			throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : Failed to save temporary file');
		}
	}
	
	public function __get($sProp) {
		if(!array_key_exists($sProp, $this->aCor) || !isset($this->aCor[$sProp]['gettable']) || false === $this->aCor[$sProp]['gettable']) {
			throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : Property '.$sProp.' is not gettable');
		}
		$sThisProp = $this->aCor[$sProp]['cor'];
		return $this->$sThisProp;
	}
	
	public function __set($sProp, $mVal) {
		if(!array_key_exists($sProp, $this->aCor) || !isset($this->aCor[$sProp]['settable']) || false === $this->aCor[$sProp]['settable'] || !isset($this->aCor[$sProp]['type'])) {
			throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : Property '.$sProp.' is not settable');			
		}
		$sFunc = $this->aCor[$sProp]['type'];
		if(!$sFunc($mVal)) {
			throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : Value '.$mVal.' is not a valid value for '.$sProp.'; waited : '.substr($sFunc, 3));	
		}
		if($sProp === 'COLOR') {
			color::interpret($this, $mVal);
			$this->sColor = $mVal;
		} elseif($sProp === 'PIXEL') {
			pixel::interpret($this, $mVal);
			$this->iThickNess = (int)$mVal;
		} elseif($sProp === 'FONTSIZE') {
			fontsize::interpret($this, $mVal);
			$this->iFontSize = (int)$mVal;
		} else {
			$sThisProp = $this->aCor[$sProp]['cor'];
			$this->$sThisProp = $mVal;
		}
	}
}
?>

Télécharger le zip

01 décembre 2007 11:24:36 :

Ajout de nombreuses fonctionnalités : tous les filtres Modification du comportement du chargement d'une image existante Modification de l'interface

01 décembre 2007 11:26:30 :

Oubli d'un filtre dans le decsriptif (négatif)

07 décembre 2007 21:16:53 :

Modifications mineurs de l'interface. Rajout du support des GIF et des JPEG (en plus des PNG). Possibilité de choisir le type lors de la sauvegarde. Possibilité de choisir la couleur de fond et les dimensions d'une nouvelle image.

07 décembre 2007 23:00:22 :

Ajout de nouveaux filtres. Ajout de la possibilité d'écrire un texte à la verticale. Ajout de la possibilité d'appliquer une rotation à l'image.

07 décembre 2007 23:02:26 :

Ajout de plusieurs nouveaux filtres. Ajout de la possibilité d'écrire un texte à la verticale. Ajout de la possibilité d'appliquer une rotation à l'image.

07 décembre 2007 23:16:04 :

Tentative pour remettre une nouvelle capture d'écran :-)

07 décembre 2007 23:19:13 :

Grr...

08 décembre 2007 14:36:55 :

Ajout de filtres et de modifications de l'image (redimensionnement, rognage)

08 décembre 2007 16:03:05 :

Petit ajout ergonomique : le outils "crop", "rectangle" et "Filled rectangle" (et bientôt "selection") bénificient désormais d'une sélection visuelle qui évolue dynamiquement avec les mouvements de la souris : bref, vous voyez un rectangle en pointillé se dessiner vous montrant les délimitations de vos outils, comme dans les logiciels de dessin évolués.

12 décembre 2007 00:46:30 :

Ajout d'une fonctionnalité "undo" permettant d'annuler la dernière action effectuée. Le paramètrage par défaut est de 10 retours en arrière possible.

13 décembre 2007 01:04:21 :

Ajout d'un outil de sélection : toutes les actions effectuées suite à une sélection se feront dans cette dernière (filtres, dessins, manipulations etc...).

24 décembre 2007 17:45:59 :

Ajout d'un "fill tool" permettant de remplir la page ou la sélection active avec une couleur. Correction d'un bug sur les sélections. Correction d'un bug sur l'outil "undo".

25 décembre 2007 13:10:01 :

Ajout d'un outil de remplissage avec un motif.

25 décembre 2007 13:11:31 :

Nettoyage du zip uploadé précedemment.