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