[PHP5] PHPDRAW - LE PHOTOSHOP DE PHP (OU PRESQUE...)

Commentaire de malalam le 08/10/2007 12:48:53 administrateur CS

Hello,

On verra ce soir si l'upload des tutos fonctionne :-)

- Les commentaires : je commente généralement quand j'ai fini un code totalement. Là, j'ai continué à modifier des trucs, d'où le peu de commentaires. Ceux qui y sont ne sont que la copie du code très simplifié que j'ai fait pour le tuto. Ceci dit, je commente généralement ainsi (et c'est ainsi que je les mettrai) :
méthode/classe/propriété
@desc
@var si propriété
@param si méthode
@return si méthode
Ce sont les seuls tags que j'utilise généralement.
Quant aux sauts de ligne : j'aime bien aérer mes codes en règle générale! ET pour le //, je ne trouve pas ça lisible. C'est vraiment simplement une préférence personnelle.

- les exceptions : j'utilise tjrs la même base pour les exceptions : j'ai généralement une classe main ou generic qui envoie des mails/logge les exceptions avec une mise en page bien précise, d'où le passage en paramètre de __CLASS__ et de __METHOD__. Là j'ai conservé les mêmes appels mais j'ai supprimé la classe parente dont je n'avais pas besoin sur ce code. Eventuellement, je peux la rajouter pour conserver une cohérence. IL y a aussi que j'aime bien voir mes messages précédés de l'appel, en plus du backtrace.

- je connais bien svg, mais ce n'était pas le but ici. J'ai voulu me caler sur GD uniquement. Ceci dit pourquoi pas imaginer différents moteurs graphiques possible en effet. On conserve l'interface, on crée des package de moteurs graphiques et un package général de classes abstraites mettant à jour les propriété, et une classe commande qui se charge du choix du moteur. Par exemple. Le "tas de classes" par contre est nécessaire dans tous les cas. Il permet d'ajouter facilement des fonctionnalités.

Ceci dit, le but était effectivement simplement d'implémenter avec un exemple plus poussé, le design pattern interprète.

Commentaire de _klesk le 08/10/2007 22:03:40

Bonsoir, je suis effectivement certain que ce code a une vertue certaine et je suis en ce moment a la recherche d'explication claire, précise et concies sur le comment du pourquoi des classes et la POO.

Cependent je n'arrive pas a faire fonctionner ce code O_o.

Cordialement.

Commentaire de malalam le 08/10/2007 22:47:48 administrateur CS

Coucou => tu peux expliquer un peu plus précisément stp, je n'ai pas saisi de quoi tu parlais?

Commentaire de malalam le 08/10/2007 23:10:37 administrateur CS

Bon ben voilà, c'est compatible IE, IE7 en tous cas.
Coucou => le but était de faire un revival simplifié du LOGO. D'avoir un langage simple et compréhensible, simplement. Clairement, ce code n'a aucune autre utilité que d'être pédagogique et d'amuser 5mn. Je ne vais pas utiliser une syntaxe complexe pour ça.  right, yp, rectangle, color...ça a le mérite d'être compréhensible par tous. Un path svg...moins ;-)
Si jamais je me lance dans un véritable éditeur graphique en php, par contre, pourquoi pas en effet! Parce que ça reste une très bonne idée. Mais pas sur ce code-ci.

Commentaire de malalam le 09/10/2007 19:53:51 administrateur CS

quelle est ta configuration ? Php et navigateur?

Commentaire de malalam le 09/10/2007 20:35:58 administrateur CS

Ca c'est très bizarre parce que moi aussi...lol.
mets toi en error_reporting(E_ALL) dans le script ajax (ajax/ajax.phpdraw.php). Il y a sûrement un message d'erreur. Ou alors, c'est le js mais Firefox devrait le dire.
Difficile de debugger comme ça à distance. Dans le pire des cas, avec Firbug, tu devrais au moins voir  le message d'erreur arriver dans la requête POST d'Ajax (dans la console, en dépliant la requête, dans l'onglet réponse).

Commentaire de _klesk le 09/10/2007 21:39:53

A y est c'est bon.

j'ai modifier inc.main.php a la ligne 4 en :define('PATH_CLASS', '../class/');
tout simplement et la ca marche.

j'ai du aussi bien sur chmoder tmpimg en 777 ;)

Merci de votre aide.

Commentaire de _klesk le 10/10/2007 00:14:14

Du coup maintenant que ca marche j'ai etoffer le fichier class.interpreter.php de façon à avoir d'autre fonction, bien sur on peu en rajouter pas mal.

<?php
/**
* Notre INTERFACE EXPRESSION
*
*/
interface expression {
public static function interpret(interpreter $subject, $mParam);
}

/**
* Une EXPRESSION CONCRETE pour les mouvements vers la droite
*
*/
class right implements expression {
public static function interpret(interpreter $subject, $mParam) {
if(!is_numeric($mParam)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid distance '.$mParam);
}
$mParam = (int)$mParam;
if (false === imageline($subject->IMG, $subject->X, $subject->Y, $subject->X+$mParam, $subject->Y, $subject->RCOLOR)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create line');
}
$subject->X += $mParam;
}
}

/**
* Une EXPRESSION CONCRETE pour les mouvements vers la gauche
*
*/
class left implements expression {
public static function interpret(interpreter $subject, $mParam) {
if(!is_numeric($mParam)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid distance '.$mParam);
}
$mParam = (int)$mParam;
if (false === imageline($subject->IMG, $subject->X, $subject->Y, $subject->X-$mParam, $subject->Y, $subject->RCOLOR)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create line');
}
$subject->X -= $mParam;
}
}

/**
* Une EXPRESSION CONCRETE pour les mouvements vers le haut
*
*/
class up implements expression {
public static function interpret(interpreter $subject, $mParam) {
if(!is_numeric($mParam)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid distance '.$mParam);
}
$mParam = (int)$mParam;
if (false === imageline($subject->IMG, $subject->X, $subject->Y, $subject->X, $subject->Y-$mParam, $subject->RCOLOR)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create line');
}
$subject->Y -= $mParam;
}
}

/**
* Une EXPRESSION CONCRETE pour les mouvements vers le bas
*
*/
class down implements expression {
public static function interpret(interpreter $subject, $mParam) {
if(!is_numeric($mParam)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid distance '.$mParam);
}
$mParam = (int)$mParam;
if (false === imageline($subject->IMG, $subject->X, $subject->Y, $subject->X, $subject->Y+$mParam, $subject->RCOLOR)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create line');
}
$subject->Y += $mParam;
}
}

/**
* 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');
}
$subject->Y += $mParam;
}
}
/**
* 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 (false === imagefilledellipse($subject->IMG, $subject->X, $subject->Y, $iWidth, $iHeight, $subject->RCOLOR)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to create ellipse');
}
$subject->Y += $mParam;
}
}
/**
* 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 ellipse');
}
$subject->Y += $mParam;
}
}


/**
* 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');
}
$subject->Y += $mParam;
}
}

/**
* 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');
}
$subject->Y += $mParam;
}
}

/**
* 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 la position X
*
*/
class x implements expression {
public static function interpret(interpreter $subject, $mParam) {
if(!is_numeric($mParam)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid position '.$mParam);
}
$mParam = (int)$mParam;
$subject->X = $mParam;
}
}

/**
* Une EXPRESSION CONCRETE pour la position Y
*
*/
class y implements expression {
public static function interpret(interpreter $subject, $mParam) {
if(!is_numeric($mParam)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : invalid position '.$mParam);
}
$mParam = (int)$mParam;
$subject->Y = $mParam;
}
}

/**
* 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 la sauvegarde de l'iamegs 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 (false === imagepng($subject->IMG, $mParam)) {
throw new languageException(__CLASS__.'::'.__FUNCTION__.'() : Failed to ssave image to file '.$mParam);
}
}
}

/**
* Notre INTERPRETER
*
*/
class interpreter {
private $iX = 200;
private $iY = 200;
private $sColor;
private $iWidth = 500;
private $iHeight = 500;
private $iThickNess = 1;
private $aDefaultDim = array(500,500);
private $oExpressionStack;
private $imh;
private $colorh;

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),
'SPIXEL' => array('cor' => 'iThickNess', 'type' => 'is_int', 'gettable' => true, 'settable' => true),
'IMG' => array('cor' => 'imh', 'type' => 'is_resource', 'gettable' => true, 'settable' => false)
);

public function __construct($sFile = null) {
if(!is_null($sFile)) {
$this->imh = @imagecreatefrompng($sFile);
if(!$this->imh) {
throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : '.$sFile.' has not been found');
}
} else {
$this->imh = imagecreatetruecolor($this->iWidth, $this->iHeight);
imagecolorallocate($this->imh, 0, 0, 0);
}
}

public function interpret ($sChaine) {
if(!is_string($sChaine)) {
throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : Parameter must be a string');
}
$this->oExpressionStack = new ArrayIterator(explode(' ', $sChaine));
$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);
}
$this->oExpressionStack->next();
$mParam = $this->oExpressionStack->current();
$interpreter = new ReflectionMethod($sToken, 'interpret');
$interpreter->invoke(null, $this, $mParam);
$this->oExpressionStack->next();
}
}

public function getMove() {
if(true === headers_sent()) {
throw new functionnalException(__CLASS__.'::'.__FUNCTION__.'() : Unable to display image, headers already sent');
}
header('Content-type: image/png');
imagepng($this->imh);
}

public function getSavedMove($sFile) {
imagepng($this->imh, $sFile);
}

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;
} else {
$sThisProp = $this->aCor[$sProp]['cor'];
$this->$sThisProp = $mVal;
}
}
}
?>

et avec ces rajout et ce code on peut obtenir des truc sympa

le bien / le mal :

x 250 y 250 filledarc 500-500-90-270 x 250 y 250 filledarc 500-500-270-180 x 250 y 250 ellipse 500-500 x 250 y 125 ellipse 250-250 x 250 y 375 color 255255255 filledellipse 250-250 color 000000000 x 253 y 125 filledellipse 247-250 color 255255255 x 250 y 125 filledellipse 110-110 color 000000000 x 250 y 375 filledellipse 110-110

Commentaire de malalam le 10/10/2007 23:15:45 administrateur CS

@_Klesk => merci :-) Et bien pour les ajouts! Tu as respecté la norme imposée, ça rentre parfaitement dans la classe. Très bien :-) Manque l'ajout de textes :-) Faut ruser un peu et trouver une nouvelle norme pour les commandes, mais c'est facilement faisable.

Commentaire de malalam le 11/10/2007 13:20:47 administrateur CS

Il suffit de les "quoter". Tu les délimites avec des guillemets, tes textes, c'est une règle, comme les autres règles de la classe. donc si tu fais par exemple: WRITE "mon texte", tu sais dans la classe que dès que tu as WRITE comme commande, tu dois avoir un texte délimité par des guillemets.

Commentaire de Steves le 12/10/2007 11:28:32

Excellent, j'aime vraiment.
Quand je pense que pour toi c'est un amusement, pour moi c'est hard.
Merci encore.

Commentaire de francisnguyen le 16/10/2007 16:18:44

Bonjour,

Chez moi ca ne marche pas ni sur IE, ni sur FF.

J'ai une config easyphp 1.8

Vous avez une idée de ce qui bloque.

J'ai aucun message d'erreur dans la console de FF.

et j'ai fait la modif dans le fichier inc.

Commentaire de malalam le 16/10/2007 20:12:37 administrateur CS

Hello,

1 - mets tous les scripts en error_reporting(E_ALL) (je devrais mettre ça par défaut sur tous mes scripts...mon php est configuré ainsi mais il est vrai que quand je partage des codes, les gens n'ont peut-être pas la même config), afin de voir si ce n'est pas une erreur php non affichée.
2 - installe firebug sur Mozilla et tâche de voir si la requête xmlhttp (ajax) se lance.
3 - y a pas de 3, on vavisera après ces 2 précédents tests :-)

Commentaire de malalam le 17/10/2007 12:45:20 administrateur CS

T'as quelle version de php...?

Commentaire de malalam le 17/10/2007 17:11:59 administrateur CS

Tu as lu le titre de mon code?
[PHP5] PHPDRAW - LE PHOTOSHOP DE PHP (OU PRESQUE...)
Y a rien qui te choque...? ;-)

Commentaire de malalam le 18/10/2007 13:07:20 administrateur CS

Oui désolé je n'ai pas encore eu le temps. Ja tâcherai de me pencher dessus ce week-end. J'espère. :-)

Commentaire de malalam le 01/11/2007 10:38:20 administrateur CS

@_KLESK => ah, petite explication quand même...c'est simple, c'est au niveau du parsing de ma chaîne de commande, tu verras que j'ai modifié la méthode. Avant je faisais un simple explode() sur les espaces. Ce n'est plus suffisant, évidemment, pour le texte délimité par des guillemets. Donc, j'ai écrit une bête petite expression régulière qui va à la fois exploser ma chaîne toujours sur les espaces, OU récupérer en entier toute chaîne entre guillemets s'il en trouve une.