<?
require('GifMerge.class.php');
#--------------------------------------------------------------------------------------
# Fonctions pour les images
#--------------------------------------------------------------------------------------
function GetExtension($fichier)
{       /* Détermine maintenant le type du fichier */
        $taille = strlen($fichier);      
	$i      = $taille;
	$fin    = 0;
	$boucle = 0;

	while(!$boucle)
	{
		$i--;
		if($i == 0) $boucle = 1;
		else if($fichier[$i] == ".")
			 {
				$fin = $i;
				$boucle = 1;
			 }
	}

	$fin++;
	$long = $taille - $fin;
	$ext = substr($fichier,$fin,$long);
      /* Fin détermination de l'extension */
return $ext;
}

function EffaceAncienneImage($Chemin, $NomImage)
{
 $chemintotal = $Chemin;	//calcul du nouveau chemin
if(file_exists($chemintotal."/".$NomImage))   
   { if (unlink("$chemintotal/$NomImage"))
     {return 1;}//fin si ulnlik
     else {return -1;}
     }//fin file exist
   else {return -2;}
}

//--------------------------------------------------------------------------
// $fichier : nom du champ du formulaire 
// $Chemin  : chemin où sera stockée l'image par exemple "./../manager/images"
// $fichier_name : passé par le formulaire, sous valeur du champ $fichier
//--------------------------------------------------------------------------


function EnregistreImage ($fichier,$Chemin,$fichier_name,$Taille)
{
 echo "le nom du fichier est : ",$fichier;
 $chemintotal = $Chemin;					//calcul du nouveau chemin
 //print $chemintotal;
  if(!empty($fichier))    
     { 
      $ext=strtolower(GetExtension($fichier_name));		
      //récupération du type de fichier jpg,bmp, png ou gif  
          
     }
 if ($ext=="png" or $ext=="jpg" or $ext=="bmp")
 {
 //Calcul du nouveau nom aléatoire
 $fichier_name_nouvelle_image = uniqid (rand());
 $fichier_name_nouvelle_image=$fichier_name_nouvelle_image.".".$ext;		
 /* Maintenant on enregistre l'image sur le serveur */ 
      //if(copy($fichier,"$chemintotal/$fichier_name")) 
      if (is_uploaded_file($fichier["fichier"]["tmp_name"])) 
        {//on deplace l'image temporaire vers le bon répertoire de travail
         copy($fichier['fichier']['tmp_name'], $chemintotal.'/'.$fichier['fichier']['name']);
         
        	//l'image est enregistrée, on va la réduire        
         //1. on l'ouvre
         //print $chemintotal;        
         $Size = getimagesize("$chemintotal/$fichier_name");                 
         $H_Src=$Size[1];//recuperation de la hauteur image originale téléchargée
         $L_Src=$Size[0];//recuperation de sa largeur       
         //print $L_Src;
          //Calcul du coefficient de réduction
          //La constante Largeurvignette   est définie dans presentation.inc
         $Taux_Reduction=$Taille/$L_Src;         
         $L_Dest=round($L_Src*$Taux_Reduction);//calcul largeur image finale de destination
         $H_Dest=round($H_Src*$Taux_Reduction);//calcul hauteur image finale de destination
         $Img_Dest=imagecreatetruecolor($L_Dest, $H_Dest);
         //On charge en mémoire l'image à modifier, celle qui est téléchargée       
         switch (strtoupper($ext))
          { case "JPG" : $Img_Src=imagecreatefromjpeg($chemintotal."/".$fichier_name);break;
            case "PNG" : $Img_Src=imagecreatefrompng($chemintotal."/".$fichier_name);break;
            case "BMP" : $Img_Src=imagecreatefromwbmp($chemintotal."/".$fichier_name);break;
            //case "GIF" : $Img_Src=imagecreatefromgif($chemintotal."/".$fichier_name);break;
        }    
        //on copie (en réduisant/grossissant) l'image originale
        //Pour l'instant l'image est en mémoire, il faut la copier sur le disque serveur :    
        
        imagecopyresized ($Img_Dest, $Img_Src,0,0,0,0,$L_Dest,$H_Dest,$L_Src,$H_Src) ;
        switch (strtoupper($ext))
          { case "JPG" : imagejpeg($Img_Dest,$chemintotal."/".$fichier_name_nouvelle_image,80);break;
            case "PNG" : imagepng($Img_Dest,$chemintotal."/".$fichier_name_nouvelle_image);break;
            case "BMP" : imagewbmp($Img_Dest,$chemintotal."/".$fichier_name_nouvelle_image);break;
            //case "GIF" : $Img_Src=imagecreatefromgif($chemintotal."/".$fichier_name_nouvelle_image);break;
        }  
        //Enfin, on detruit l'image téléchargée aux mauvaises dimensions
        EffaceAncienneImage($chemintotal, $fichier_name);
        //on retourne le nom du fichier créé!
        return $fichier_name_nouvelle_image;
        }			// retour du nom de fichier
	else {return -2;}			// -2 si la copie n'est pas faite
	} else {return -3;} //Le format du fichier n'est pas bon!

/*fin enregistrement image */
 
}

function drawboldtext($image, $size, $angle, $x_cord, $y_cord, $r, $g, $b, $fontfile, $text) 
{  $LargeurLettre=0;
   $color = ImageColorAllocate($image, $r, $g, $b); 
   $_x = array(2, 0, 2, 0, -2, -2, 2, 0, -2); 
   $_y = array(0, -2, -2, 0, 0, -2, 2, 2, 2); 
	 
  	     for($n=0;$n<=8;$n++) 
         { 
          ImageTTFText($image, $size, $angle, $x_cord+$_x[$n]+$LargeurLettre, $y_cord+$_y[$n], $color, $fontfile, $text); 
         } 
         
} 

function Imagettftext_Cr(&$im, $size, $angle, $x, $y, $color, $fontfile, $text)
       {
           // retrieve boundingbox
           $bbox = imagettfbbox($size, $angle, $fontfile, $text);           
           // calculate deviation
           $dx = ($bbox[2]-$bbox[0])/2.0 - ($bbox[2]-$bbox[4])/2.0;        // deviation left-right
           $dy = ($bbox[3]-$bbox[1])/2.0 + ($bbox[7]-$bbox[1])/2.0;        // deviation top-bottom           
           // new pivotpoint
           $px = $x-$dx;
           $py = $y-$dy;           
           return imagettftext($im, $size, $angle, $px, $py, $color, $fontfile, $text);
       }


function My_Is_Nan($var) {
//return !ereg ("^[-]?[0-9]+([\.][0-9]+)?$", $var);
  if ($var/1) return false;
    else return true;
}


/*---------------------------------------------------------------------------------------------------------
  crée une image de bandeau en utilisant une image source. $LargeurImage est la largeur de redimensionnement
  demandée par l'utilisateur. Si elle est égale à Zero, alors l'image créé conserve ses dimensions d'origine.
  Si width, ou height ou couleur sont renseignés, alors on crée ue image vide.
  on crée une image de taille $Width, $Height et  de couleur $Couleur (FFGGOO)
  
  --------------------------------------------------------------------------------------------------------*/ 
function Cree_Fond_Bandeau($fichier_name,$LargeurImage,$Width,$Height,$Couleur) {		
if ($Width=='' && $Height=='' && $Couleur=='')
  {//chercher le fichier image!
  	//on a demandé une image fichier existant sur le disuqe dur
	if (getenv("REMOTE_ADDR")!="127.0.0.1")
     {	
      $chemintotal="/home/byjad/public_html/bijoux pendentifs colliers/";
      $extension_police=".ttf";
      }
      else {
      $chemintotal="./bijoux pendentifs colliers";
      $extension_police="";
      }
      $Size = getimagesize("$chemintotal/$fichier_name");                 
      $H_Src=$Size[1];//recuperation de la hauteur image originale téléchargée
      $L_Src=$Size[0];//recuperation de sa largeur  
      $ext=strtolower(GetExtension("$chemintotal/$fichier_name"));	
      //redimensionnement de l'image de fond si nécessaire
     if ($LargeurImage!=0)
    {//on spécifie un autre largeur que la largeur normale de l'image
     //on recrée une image redmensionnée
      $Taux_Reduction=$LargeurImage/$L_Src; 
      //echo "taux de réduction : ",$Taux_Reduction."<br>";                
      $L_Dest=$L_Src*$Taux_Reduction;
      $H_Dest=$H_Src*$Taux_Reduction;//calcul hauteur image finale de destination
      //echo "Largeur réduite : ",$L_Dest,", Hauteur réduite : ",$H_Dest."<br>";
      $Image2=imagecreatetruecolor($L_Dest, $H_Dest);
      $Couleur1 = imagecolorallocate($Image2,255,255,255);  
      //imagefill($Image2,0,0,$Couleur1);
      //imagecolortransparent($Image2,$Couleur1);                	
      switch (strtoupper($ext))
          { case "JPG" : $Img_Src=imagecreatefromjpeg($chemintotal."/".$fichier_name);break;
            case "PNG" : $Img_Src=imagecreatefrompng($chemintotal."/".$fichier_name);break;
            case "BMP" : $Img_Src=imagecreatefromwbmp($chemintotal."/".$fichier_name);break;           
        }                              
      imagecopyresized ($Image2, $Img_Src,0,0,0,0,$L_Dest,$H_Dest,$L_Src,$H_Src) ;
      imagedestroy($Img_Src);
      $L_Src=$L_Dest;
      $H_Src=$H_Dest;
      //echo "Larguer = ",$L_Src," et hauteur : ",$H_Src."<br>";
    }
    else {//charge directement l'image
    	    switch (strtoupper($ext))
          { case "JPG" : $Image2=imagecreatefromjpeg($chemintotal."/".$fichier_name);break;
            case "PNG" : $Image2=imagecreatefrompng($chemintotal."/".$fichier_name);break;
            case "BMP" : $Image2=imagecreatefromwbmp($chemintotal."/".$fichier_name);break;           
        }                              
    	   }
 } else {//on a demandé une iamge vide
 	       $Image2=imagecreatetruecolor($Width,$Height); 	       	        
         $rouge = hexdec(substr($Couleur,0,2)); 
         $vert = hexdec(substr($Couleur,2,2));
         $bleu = hexdec(substr($Couleur,4,2));
         $Couleur1 = imagecolorallocate($Image2,$rouge,$vert,$bleu);  
 	       imagefill($Image2,0,0,$Couleur1); 	       
 	      }
return $Image2;    	   
}

/*------------------------------------------------------------------------------------------------------------
 * crée une bannière étoilée, sur laquelle un texte est écrit. Utilisé en ahut des écrans
 *----------------------------------------------------------------------------------------------------------*/
 function Cree_Bandeau_Titre_Anime($Largeur,$Hauteur,$text)
    {
    //crée le bandeau coloré qui contiendra le texte
    $Image2=Cree_Fond_Bandeau('',0,$Largeur,$Hauteur,COULEUR_FOND_BANDEAU_GENERAL);
    $L_Src=imagesx($Image2);
    $H_Src=imagesy($Image2);                
    
    for ($i=0;$i<13;$i++)
       {$X=rand(10,$L_Src-5);
        $Y=rand(10,$H_Src-5);       
        $Taille=rand(1,40);
        $Rotation=rand(0,45);
        //calculs dapres parametres
        $LargeurEtoile=intval($Taille*70/100);		
        $LargeurInterieurEtoile=intval($Taille/100*40);
        Polygone($Image2,$X,$Y,intval($LargeurEtoile*1.1),$LargeurEtoile,intval($LargeurInterieurEtoile*1.1),$LargeurInterieurEtoile,5,$Rotation,COULEUR_ETOILE_BANDEAU_GENERAL);        
       }    
       
      Cree_Text_Volant($Image2,$L_Src,100,strtoupper($text),POLICE_TITRE_BANDEAU_GENERAL,TAILLE_POLICE_BANDEAU_GENERAL,COULEUR_TITRE_BANDEAU,COULEUR_BORD_TITRE_BANDEAU);
       
     return $Image2;
    }

 function Cree_Bandeau_Titre_Classic($Largeur,$Hauteur,$text)
    {
    //crée le bandeau coloré qui contiendra le texte
    $Image2=Cree_Fond_Bandeau('',0,$Largeur,$Hauteur,COULEUR_FOND_BANDEAU_GENERAL);    
    $Image2=Cree_Texte($Image2,0,0,$Largeur,$Hauteur,ucfirst($text),POLICE_TITRE_BANDEAU_CLASSIC,TAILLE_POLICE_FOND_CLASSIC,COULEUR_POLICE_FOND_CLASSIC,"Centre","Centre");   
    $L_Src=imagesx($Image2);
    $H_Src=imagesy($Image2);                
    for ($i=0;$i<13;$i++)
       {$X=rand(10,$L_Src-5);
        $Y=rand(10,$H_Src-5);       
        $Taille=rand(1,40);
        $Rotation=rand(0,45);
        //calculs dapres parametres
        $LargeurEtoile=intval($Taille*70/100);		
        $LargeurInterieurEtoile=intval($Taille/100*40);
        Polygone($Image2,$X,$Y,intval($LargeurEtoile*1.1),$LargeurEtoile,intval($LargeurInterieurEtoile*1.1),$LargeurInterieurEtoile,5,$Rotation,COULEUR_ETOILE_BANDEAU_GENERAL);        
       }    
       //recherche de la taille du texte
       
       $Image2=Cree_Texte($Image2,20,70,$Largeur,$Hauteur,ucfirst($text),POLICE_TITRE_BANDEAU_CLASSIC,TAILLE_POLICE_BANDEAU_CLASSIC,COULEUR_TITRE_BANDEAU_CLASSIC,ALIGNEMENT_TITRE_BANDEAU_CLASSIC_HORIZ,ALIGNEMENT_TITRE_BANDEAU_CLASSIC_VERT);      
       
     return $Image2;
    }

/*------------------------------------------------------------------------------------------------------------------
 ecrit un texte dans le cadre de hauteur et largeur, justifié comme demandé
 si largeur et haueur non spécifiés, écrit le texte à X et Y
 -----------------------------------------------------------------------------------------------------------------*/
function Cree_Texte($Image, $X,$Y,$Largeur,$Hauteur,$Texte,$Police,$Taille_Police,$Couleur,$JustificationHoriz,$JustificationVert)
{$Chemin_Police="/polices";
 if (getenv("REMOTE_ADDR")!="127.0.0.1") {	$extension_police=".ttf";} else {$extension_police="";}                
 putenv('GDFONTPATH=' . realpath('.'));
 $font = $Chemin_Police."/".$Police.$extension_police; // a remplacer par votre police    
 //determiner la couleur
 $rouge = hexdec(substr($Couleur,0,2)); 
 $vert = hexdec(substr($Couleur,2,2));
 $bleu = hexdec(substr($Couleur,4,2));
 $CouleurText = ImageColorAllocate($Image, $rouge,$vert,$bleu);   
 //ecrire le texte en true type
 if ($Hauteur!='' && $Largeur!='')
    {//recherche de la largeur du texte ecrit
    $size = imagettfbbox($Taille_Police,0,$font,$Texte);        
    $LargeurMot=abs($size[2]-$size[0]); //largeur 
    $HauteurMot = abs($size[5]-$size[3]);//hauteurtheorique    	
     //cas du centrage
     switch ($JustificationHoriz)
       { case "Gauche" : $X=$X; break;
         case "Centre" : $X=($Largeur-$LargeurMot)/2; break;
         case "Droite" ; $X=$Largeur-$LargeurMot; break;
       }
    switch ($JustificationVert)
       { case "Haut" : $Y=$HauteurMot; break;
         case "Centre" : if ($HauteurMot<$Hauteur) {$Y=($Hauteur+$HauteurMot)/2;}
                         else {//le texte ne tient pas dans l'image prévue
                         	     $Y=$Hauteur;} break;
         case "Bas" : $Y=$Hauteur-$HauteurMot; break;
       }
    }
 ImageTTFText($Image, $Taille_Police,0,$X, $Y, $CouleurText, $font, $Texte);   
 return $Image;  
}


/*--------------------------------------------------------------------------------------------------------------
 retourne la largeur et hauteur d'un texte écrit par créé texte
 -------------------------------------------------------------------------------------------------------------*/

function Dimension_Cree_Texte($Texte,$Police,$Taille_Police)
{$Chemin_Police="/polices";
 if (getenv("REMOTE_ADDR")!="127.0.0.1") {	$extension_police=".ttf";}else {$extension_police="";}                
 putenv('GDFONTPATH=' . realpath('.'));
 $font = $Chemin_Police."/".$Police.$extension_police; // a remplacer par votre police     
 $size = imagettfbbox($Taille_Police,0,$font,$Texte);        
 $LargeurMot=abs($size[2]-$size[0]); //largeur 
 $HauteurMot = abs($size[5]-$size[3]);//hauteurtheorique    	
 $Dimension[0]=$LargeurMot;
 $Dimension[1]=$HauteurMot;   
 return $Dimension;  
}


/*--------------------------------------------------------------------------------------------------------------
 * écrit un texte "volant" entouré ou non de plus gras
 *------------------------------------------------------------------------------------------------------------*/
function Cree_Text_Volant($Image2,$L_Src,$H_Src,$text,$Police,$Taille_Police,$CouleurTexteHexa,$CouleurBord)
{   
	  $Chemin_Police="/polices";
     if (getenv("REMOTE_ADDR")!="127.0.0.1") {	$extension_police=".ttf";}else {$extension_police="";}                
     putenv('GDFONTPATH=' . realpath('.'));
     $font = $Chemin_Police."/".$Police.$extension_police; // a remplacer par votre police   
     
	  $Angle1=rand(7,20);
    $Angle2=-rand(7,20);
    //traitement du texte sur plusieurs lignes
    $Texte=explode("|",$text);
    $NbrePhrase=count($Texte);
    
    $Ordonnee=intval($H_Src/15);
    for ($j=0;$j<$NbrePhrase;$j++)
    {$Ordonnee=$Ordonnee+intval($Taille_Police*1.5);
    $text=$Texte[$j];
    //creation de la phrase sur ligne en cours	     
    $LargeurSup=0;
    $LargeurLettrePrec=0;
    $HauteurLettrePrec=0;
    $AngleLettre=15;
    $AbscisseSup=0;
    $AbscisseLettre=0;        
    //on va découper le mot en plusieurs lettres
    for ($i=0;$i<strlen($text);$i++)
        {//tant que de lettres dans le mot
         $LargeurLettrePrec=$LargeurLettrePrec+$LargeurLettre;                 
         $Lettre=substr($text,$i,1);
         //echo "largeur lettreprec : ",$LargeurLettrePrec."<br>";
         //angle de la lettre en cours
         if($AngleLettre==$Angle1) {$AngleLettre=$Angle2;} else {$AngleLettre=$Angle1;}
         //recherche de la largeur de la lettre, compte tenu de l'angle d'écriture
         $size = imagettfbbox($Taille_Police,0,$font,$Lettre);
         //abscisse de la lettre en cours, posée droite normalement          
         if ($Lettre==" ") {$LargeurLettre=intval($HauteurLettre/1.5);} else {$LargeurLettre = abs($size[2]-$size[0]);} //largeur 
         //$HauteurLettre = abs($size[5]-$size[3]);//hauteurtheorique qu de le lettre 
         //$HauteurLettre=($LargeurLettre*sin(deg2rad(90)))/sin(deg2rad(90)-deg2rad($AngleLettre));
         //echo "Largeur nouvelle : ",$LargeurLettre,", HauteurNouvelle : ",$HauteurLettre,"<br>";
         //$HauteurLettre=$Taille_Police;                
         //$AbscisseSup=-intval($HauteurLettre*sin(deg2rad(180)+deg2rad($AngleLettre)))-intval($Taille_Police/3);
         $AbscisseSup=$Taille_Police/3;
         //echo "Abscisse sup : ",$AbscisseSup,"<br>";
         
         $AbscisseLettre=$LargeurLettrePrec+$AbscisseSup;
         $LargeurLettre=$LargeurLettre+$AbscisseSup;        
        }
   //ici largeurlettre contient la taille complète du texte à afficher
    //on va donc pouvoir le centrer
    $DecalageAbscisseCentrage=intval(($L_Src-($AbscisseLettre+$LargeurLettre))/2);
    //on recommence la procedure, mais cette fois ci on écrit toutes les lettres
    $LargeurSup=0;
    $LargeurLettrePrec=0;
    $LargeurLettre=0;
    $HauteurLettre=0;
    $HauteurLettrePrec=0;
    $AngleLettre=15;
    $AbscisseSup=0;
    $AbscisseLettre=0;
    //definition de la couleur
    $Couleur2=$CouleurTexteHexa;    
    $rouge = hexdec(substr($Couleur2,0,2)); 
    $vert = hexdec(substr($Couleur2,2,2));
    $bleu = hexdec(substr($Couleur2,4,2));
    $CouleurText = ImageColorAllocate($Image2, $rouge,$vert,$bleu);         
    //on va découper le mot en plusieurs lettres
    for ($i=0;$i<strlen($text);$i++)
        {//tant que de lettres dans le mot
         $LargeurLettrePrec=$LargeurLettrePrec+$LargeurLettre;                 
         $Lettre=substr($text,$i,1);
         //echo "largeur lettreprec : ",$LargeurLettrePrec."<br>";
         //angle de la lettre en cours
         if($AngleLettre==$Angle1) {$AngleLettre=$Angle2;} else {$AngleLettre=$Angle1;}
         //recherche de la largeur de la lettre, compte tenu de l'angle d'écriture
         $size = imagettfbbox($Taille_Police,0,$font,$Lettre);
         //abscisse de la lettre en cours, posée droite normalement          
         if ($Lettre==" ") {$LargeurLettre=intval($HauteurLettre/1.5);} else {$LargeurLettre = abs($size[2]-$size[0]);} //largeur 
         $HauteurLettre = abs($size[5]-$size[3]);//hauteurtheorique qu de le lettre 
         //$HauteurLettre=($LargeurLettre*sin(deg2rad(90)))/sin(deg2rad(90)-deg2rad($AngleLettre));                
         //$AbscisseSup=-intval($HauteurLettre*sin(deg2rad(180)+deg2rad($AngleLettre)))-intval($Taille_Police/3);                                    
         $AbscisseSup=$Taille_Police/3;
         $AbscisseLettre=$LargeurLettrePrec+$AbscisseSup;
         $LargeurLettre=$LargeurLettre+$AbscisseSup;
         if (isset($CouleurBord) && ($CouleurBord!=''))
           {$rouge = hexdec(substr($CouleurBord,0,2)); 
            $vert = hexdec(substr($CouleurBord,2,2));
            $bleu = hexdec(substr($CouleurBord,4,2));
           	drawboldtext($Image2, $Taille_Police, $AngleLettre, $AbscisseLettre+$DecalageAbscisseCentrage, $Ordonnee, $rouge, $vert, $bleu, $font, $Lettre);
           }        
         ImageTTFText($Image2, $Taille_Police,$AngleLettre, $AbscisseLettre+$DecalageAbscisseCentrage, $Ordonnee, $CouleurText, $font, $Lettre); 
        }    
        
	}//fin for autant que de lignes!
	
	
	return $LargeurLettrePrec;  //retourne la largeur du mot!
}
                        
//retourne le tableau des points nécessaires à un plygone

function Tableau_Polygone($XCentre,$YCentre,$DimensionExterieureWidth,$DimensionExterieureHeight,$DimensionInterieureWidth,$DimensionInterieureHeight,$Branches,$Rotation)
{
	
  //$xPoints contient les abscisses
   //$yPoints contient les ordonnées
   $Rotation=deg2rad($Rotation);
   $Delta=pi()*2/$Branches;
   $Angle=0;
   for ($i=0;$i<$Branches;$i++) //tant que de branches
     { if ($DimensionInterieureWidth!=$DimensionExterieureWidth && $DimensionInterieureHeight!=$DimensionEXterieureHeight)
            {//si dimension differentes
            $Angle=($Delta*$i);
            $xPoints[$i*2]=intval($DimensionExterieureWidth*cos($Angle+$Rotation)+0.5)+$XCentre;
            $yPoints[$i*2]=$YCentre-intval($DimensionExterieureHeight*sin($Angle+$Rotation)+0.5);
            $Angle=$Angle+($Delta/2);
            $xPoints[$i*2+1]=intval($DimensionInterieureWidth*cos($Angle+$Rotation)+0.5)+$XCentre;
            $yPoints[$i*2+1]=$YCentre-intval($DimensionInterieureHeight*sin($Angle+$Rotation)+0.5);            
            }//fin si dimension differentes
            else {//tracé d'un polygone régulier!
                  $Angle=$Delta*$i+pi()/2;                  
                  $xPoints[$i]=intval($DimensionExterieureWidth*cos($Angle+$Rotation)+0.5)+$XCentre;
                  $yPoints[$i]=$YCentre-intval($DimensionExterieureHeight*sin($Angle+$Rotation)+0.5);
                  
                 }
     } // fin for


//cree le tableau $coords
for ($i=0;$i<count($xPoints);$i++)
     {$coords[$i*2]=$xPoints[$i];
      $coords[$i*2+1]=$yPoints[$i];
     } 
return $coords; 	
}


function Polygone($Image,$XCentre,$YCentre,$DimensionExterieureWidth,$DimensionExterieureHeight,$DimensionInterieureWidth,$DimensionInterieureHeight,$Branches,$Rotation,$Couleur)
{ 
$coords=Tableau_Polygone($XCentre,$YCentre,$DimensionExterieureWidth,$DimensionExterieureHeight,$DimensionInterieureWidth,$DimensionInterieureHeight,$Branches,$Rotation);
$rouge = hexdec(substr($Couleur,0,2)); 
$vert = hexdec(substr($Couleur,2,2));
$bleu = hexdec(substr($Couleur,4,2));
$Couleur1 = imagecolorallocate($Image,$rouge,$vert,$bleu);
imagefilledpolygon($Image,$coords,intval(count($coords)/2),$Couleur1);

}  

/* -------------------------------------------------------------------------------------------------------------------
   Crée le groupement d'étoiles vectoriel
   ------------------------------------------------------------------------------------------------------------------*/

function Cree_Ambiance_Etoile($Image,$XCentre,$YCentre,$Taille,$Couleur)
{ $LargeurEtoile=intval($Taille*70/100);		
  $LargeurInterieurEtoile=intval($Taille/100*40);
  $Rotation=20;
	Polygone($Image,$XCentre,$YCentre,intval($LargeurEtoile*1.1),$LargeurEtoile,intval($LargeurInterieurEtoile*1.1),$LargeurInterieurEtoile,5,$Rotation,$Couleur);
	$Rotation=0;
  $CoefficientReduction=5;
  $LargeurE=intval($LargeurEtoile/$CoefficientReduction);
  $LargeurInterieurE=intval($LargeurInterieurEtoile/$CoefficientReduction);  
  $XE=intval($XCentre-($LargeurEtoile));
  $YE=intval($YCentre+$LargeurEtoile*0.2);
  Polygone($Image,$XE,$YE,$LargeurE,$LargeurE,$LargeurInterieurE,$LargeurInterieurE,5,$Rotation,$Couleur);
  $CoefficientReduction=7;
  $Rotation=50;
  $LargeurE=intval($LargeurEtoile/$CoefficientReduction);
  $LargeurInterieurE=intval($LargeurInterieurEtoile/$CoefficientReduction);  
  $XE=intval($XCentre-($LargeurEtoile*0.7));
  $YE=intval($YCentre+$LargeurEtoile*0.6);
  Polygone($Image,$XE,$YE,$LargeurE,$LargeurE,$LargeurInterieurE,$LargeurInterieurE,6,$Rotation,$Couleur);
	$Rotation=60;
  $CoefficientReduction=7;
  $LargeurE=intval($LargeurEtoile/$CoefficientReduction);
  $LargeurInterieurE=intval($LargeurInterieurEtoile/$CoefficientReduction);  
  $XE=intval($XCentre-($LargeurEtoile*0.5));
  $YE=intval($YCentre-$LargeurEtoile*0.58);
  Polygone($Image,$XE,$YE,$LargeurE,$LargeurE,$LargeurInterieurE,$LargeurInterieurE,4,$Rotation,$Couleur);
  $Rotation=80;
  $CoefficientReduction=9;
  $LargeurE=intval($LargeurEtoile/$CoefficientReduction);
  $LargeurInterieurE=intval($LargeurInterieurEtoile/$CoefficientReduction);  
  $XE=intval($XCentre-($LargeurEtoile*0.8));
  $YE=intval($YCentre-$LargeurEtoile*0.60);
  Polygone($Image,$XE,$YE,$LargeurE,$LargeurE,$LargeurInterieurE,$LargeurInterieurE,5,$Rotation,$Couleur);
  $Rotation=45;
  $CoefficientReduction=13;
  $LargeurE=intval($LargeurEtoile/$CoefficientReduction);
  $LargeurInterieurE=intval($LargeurInterieurEtoile/$CoefficientReduction);  
  $XE=intval($XCentre-($LargeurEtoile*0.1));
  $YE=intval($YCentre+$LargeurEtoile*0.75);
  Polygone($Image,$XE,$YE,$LargeurE,$LargeurE,$LargeurInterieurE,$LargeurInterieurE,5,$Rotation,$Couleur);
  $Rotation=45;
  $CoefficientReduction=10;
  $LargeurE=intval($LargeurEtoile/$CoefficientReduction);
  $LargeurInterieurE=intval($LargeurInterieurEtoile/$CoefficientReduction);  
  $XE=intval($XCentre+($LargeurEtoile*0.02));
  $YE=intval($YCentre+$LargeurEtoile*0.80);
  Polygone($Image,$XE,$YE,$LargeurE,$LargeurE,$LargeurInterieurE,$LargeurInterieurE,5,$Rotation,$Couleur);
}

//retourne la largeur en pixels de l'affichette du prix
function Cree_Dimension_Prix($X,$Y,$TaillePrix,$Prix)
{
	$LargeurEtoile=intval($TaillePrix*70/100);		
	
		$Texte=explode("|",$Prix);
	$NbrePhrase=count($Texte);  
	$Taille_Police=10*$TaillePrix;
 
  putenv('GDFONTPATH=' . realpath('.'));
  if (getenv("REMOTE_ADDR")!="127.0.0.1") {	$extension_police=".ttf";}else {$extension_police="";}
  $Chemin_Police="/polices";   
  $font = $Chemin_Police."/".FONT_PRIX_COM.$extension_police; // a remplacer par votre police   
 
 //affichage de l'étoile
 //calcul de la plus grande Largeur
 $LargeurEtoile=0;

 for ($i=0;$i<$NbrePhrase;$i++)
 {if (!My_Is_Nan($Texte[$i]))
	  {//on a transmis un nombre             
     $DernierCaractere=substr($Texte[$i],strlen($Texte[$i])-1,1); 
	   if ($DernierCaractere!="%") {$DernierCaractere="";} 	  	   
	   $TexteT[$i]=number_format($Texte[$i],2,'.','');	    
	   $Temp=explode(".",$TexteT[$i]);
     $Nombre=$Temp[0];
     $Decimale=$Temp[1];                    
     if ($Decimale=="00") 
         {if ($DernierCaractere!="%")
             {$Decimale=".".$Decimale;} else {$Nombre=$Nombre.$DernierCaractere;
                                              $Decimale=""; }
         } else 
            {$Decimale=".".$Decimale.$DernierCaractere;}
     //$Lettre=$DernierCaractere;    
     $Lettre=$Nombre;       
    }// sinon c'est une phrase
    else { $Lettre=$Texte[$i];    	                                    
    	   } 
  //centrage sur étoile
  $size = imagettfbbox($Taille_Police,0,$font,$Lettre);
  $LargeurTemp=abs($size[0]-$size[2]);
  if (!My_Is_Nan($Texte[$i]))
  {
  $Taille_Police=$Taille_Police/2;
  $size = imagettfbbox($Taille_Police,0,$font,".".$Decimale);
  $LargeurTemp=$LargeurTemp+abs($size[0]-$size[2]);  
  $Taille_Police=$Taille_Police*2;
  } 
  if ($LargeurTemp>$LargeurEtoile) {$LargeurEtoile=$LargeurTemp;}
 }
				
	//$Dimension[0]=$LargeurEtoile*1.5;
	//$Dimension[1]=$LargeurEtoile/1.2;
 return Dimension_Polygone(0,0,$LargeurEtoile*0.7,$LargeurEtoile*0.7,$LargeurEtoile*0.4,$LargeurEtoile*0.4,5,20);
 
}

/* -------------------------------------------------------------------------------------------------------------------
   trouve la dimension d'un Polygone
   -----------------------------------------------------------------------------------------------------------------*/
function Dimension_Polygone($X,$Y,$DimensionExterieureWidth,$DimensionExterieureHeight,$DimensionInterieureWidth,$DimensionInterieureHeight,$Branches,$Rotation)
{
	 
	$coord=Tableau_Polygone(0,0,$DimensionExterieureWidth,$DimensionExterieureHeight,$DimensionInterieureWidth,$DimensionInterieureHeight,$Branches,$Rotation);
	$maxX=0;
	$minX=0;
	for ($i=0;$i<count($coord)/2;$i++)
	    { if ($coord[$i*2]>$maxX) {$maxX=$coord[$i*2];
	    	                        }
	    	if ($coord[$i*2]<$minX) {$minX=$coord[$i*2]; }                       
	    }
	//$Largeur=$maxX-intval($minX);
	$Largeur=abs($maxX)+abs($minX);
   
  $maxY=0;
	$minY=0;
	for ($i=0;$i<count($coord)/2;$i++)
	    { if ($coord[($i*2)+1]>$maxY) {$maxY=$coord[($i*2)+1];
	    	                        }
	    	if ($coord[($i*2)+1]<$minY) {$minY=$coord[($i*2)+1]; } 	    	 	                      
	    }
	$Hauteur=abs($maxY)+abs($minY);
	//$Hauteur=$maxY-$minY;
	$Dimension[0]=$Largeur;
	$Dimension[1]=$Hauteur;
	return $Dimension;
}


/* -------------------------------------------------------------------------------------------------------------------
   Crée l'affichage des prix sur les mages
   Ajoute un rix sur fond rouge, avec ou sans etoile groupee.
   //si etoile est égale à "Non", le prix est seul en rouge!
   //on peut choisir le cote X et Y, la taille et si c'est sur fond rouge ou non
   ------------------------------------------------------------------------------------------------------------------*/
function Cree_Prix($Image, $XCentre,$YCentre,$Prix,$TaillePrix,$Etoile)
{//cette fonction affiche un prix sur une ambiance étoilée
	$Texte=explode("|",$Prix);
	$NbrePhrase=count($Texte);  
	$Taille_Police=10*$TaillePrix;
 $AngleLettre=0;
 //$AbscisseLettre=intval($XCentre+$Taille_Police)/3;
 $AbscisseLettre=$XCentre;
 
  putenv('GDFONTPATH=' . realpath('.'));
  if (getenv("REMOTE_ADDR")!="127.0.0.1") {	$extension_police=".ttf";}else {$extension_police="";}
  $Chemin_Police="/polices";   
  //$Police2="COOPBL";
  $font = $Chemin_Police."/".FONT_PRIX_COM.$extension_police; // a remplacer par votre police   
 
 //affichage de l'étoile
 //calcul de la plus grande Largeur
 $LargeurEtoile=0;
 if ($Etoile!="Non")
 {
 for ($i=0;$i<$NbrePhrase;$i++)
 {if (!My_Is_Nan($Texte[$i]))
	  {//on a transmis un nombre             
     $DernierCaractere=substr($Texte[$i],strlen($Texte[$i])-1,1); 
	   if ($DernierCaractere!="%") {$DernierCaractere="";} 	  	   
	   $TexteT[$i]=number_format($Texte[$i],2,'.','');	    
	   $Temp=explode(".",$TexteT[$i]);
     $Nombre=$Temp[0];
     $Decimale=$Temp[1];                    
     if ($Decimale=="00") 
         {if ($DernierCaractere!="%")
             {$Decimale=".".$Decimale;} else {$Nombre=$Nombre.$DernierCaractere;
                                              $Decimale=""; }
         } else 
            {$Decimale=".".$Decimale.$DernierCaractere;}
     //$Lettre=$DernierCaractere;    
     $Lettre=$Nombre;       
    }// sinon c'est une phrase
    else { $Lettre=$Texte[$i];    	                                    
    	   } 
  //centrage sur étoile
  $size = imagettfbbox($Taille_Police,0,$font,$Lettre);
  $LargeurTemp=abs($size[0]-$size[2]);
  if (!My_Is_Nan($Texte[$i]))
  {
  $Taille_Police=$Taille_Police/2;
  $size = imagettfbbox($Taille_Police,0,$font,".".$Decimale);
  $LargeurTemp=$LargeurTemp+abs($size[0]-$size[2]);  
  $Taille_Police=$Taille_Police*2;
  } 
  if ($LargeurTemp>$LargeurEtoile) {$LargeurEtoile=$LargeurTemp;}
 }
 Cree_Ambiance_Etoile($Image,$XCentre,$YCentre+intval($Taille_Police/8),$LargeurEtoile,COULEUR_ETOILES_PRIX);
 }
  //tant que de lignes à afficher dans l'étoile!
  $DecalageTexte=0;
  for ($i=0;$i<$NbrePhrase;$i++)
  { 
 $Taille_Police=10*$TaillePrix;
  if (!My_Is_Nan($Texte[$i]))
	  {//on a transmis un nombre	 	     	   
	   $DernierCaractere=substr($Texte[$i],strlen($Texte[$i])-1,1); 
	   if ($DernierCaractere!="%") {$DernierCaractere="";} 	  	   
	   $Texte[$i]=number_format($Texte[$i],2,'.','');	    
	   $Temp=explode(".",$Texte[$i]);
     $Nombre=$Temp[0];
     $Decimale=$Temp[1];                    
     if ($Decimale=="00") 
         {if ($DernierCaractere!="%")
             {$Decimale=".".$Decimale;} else {$Nombre=$Nombre.$DernierCaractere;
                                              $Decimale=""; }
         } else 
            {$Decimale=".".$Decimale.$DernierCaractere;}
     //$Lettre=$DernierCaractere;    
     $Lettre=$Nombre;       
    }// sinon c'est une phrase
    else { $Lettre=$Texte[$i];    	                                    
    	   } 
 
  //centrage sur étoile
  $size = imagettfbbox($Taille_Police,0,$font,$Lettre);
  $LargeurTotale=abs($size[0]-$size[2]);
  if (!My_Is_Nan($Texte[$i]))
  {
  $Taille_Police=$Taille_Police/2;
  $size = imagettfbbox($Taille_Police,0,$font,".".$Decimale);
  $LargeurTotale=$LargeurTotale+abs($size[0]-$size[2]);  
  $Taille_Police=$Taille_Police*2;
  }  
  $Decalage=$LargeurTotale/2;  
  $DecalageY=$Taille_Police/6.2; 
  drawboldtext($Image, $Taille_Police, 0, $AbscisseLettre+$Coefficient-$Decalage, $YCentre-$DecalageY+$DecalageTexte, 231, 28, 24, $font, $Lettre) ;
  $CouleurText = imagecolorallocate($Image,255,255,255);
  ImageTTFText($Image, $Taille_Police*0.95,0, $AbscisseLettre+$Coefficient-$Decalage, $YCentre-$DecalageY+$DecalageTexte, $CouleurText, $font, $Lettre); 
  if (!My_Is_Nan($Texte[$i]))
  {//dans le cas d'un nombre, on affiche les décimales!
  $size = imagettfbbox($Taille_Police,0,$font,$Lettre);
  $LargeurPrix=abs($size[0]-$size[2])-strlen($Lettre);
  $HauteurPrix=abs($size[5]-$size[3]);
  $Lettre=$Decimale;
  $Taille_Police=$Taille_Police/2;
  //$Coefficient=intval($Taille_Police/8); 
  //$Coefficient=0;
  $size = imagettfbbox($Taille_Police,0,$font,$Lettre);
  $HauteurPrix2=abs($size[5]-$size[3]);
  //$CouleurText = imagecolorallocate($Image,255,255,255);
  drawboldtext($Image, $Taille_Police, 0, $AbscisseLettre+$LargeurPrix-$Decalage, $YCentre-($DecalageY)-$HauteurPrix+$HauteurPrix2+($Coefficient*5)+$DecalageTexte, 231, 28, 24, $font, $Lettre) ;
  ImageTTFText($Image, $Taille_Police,0, $AbscisseLettre+$LargeurPrix-$Decalage, $YCentre-($DecalageY)-$HauteurPrix+$HauteurPrix2+($Coefficient*5)+$DecalageTexte, $CouleurText, $font,$Lettre); 
  }
  $Taille_Police=10*$TaillePrix;
  $DecalageTexte=$DecalageTexte+$Taille_Police*1.3;
}//fin tant que de lignes à afficher    
}


/*---------------------------------------------------------------------------------------------------------------------
 Image_Cree_prix
 Crée un prix sous forme d'ambiance étoilée qui s'affiche avec justification gauche, centre, droit et haut, centre, bas,
 le tout par rapport à l'image en cours $Image2
 --------------------------------------------------------------------------------------------------------------------*/
 function Image_Cree_Prix($Image2,$text,$Taille,$DirectionX,$DirectionY)
{           
    $L_Src=imagesx($Image2);
    $H_Src=imagesy($Image2);        
    $Marge=6;                
    $Dimension=Cree_Dimension_Prix($L_Src/2,$H_Src/2,$Taille,$text);
    $LargeurPrix=$Dimension[0];
    $HauteurPrix=$Dimension[1];
    switch ($DirectionX)
        { case "Gauche" : $X=$Marge+$Taille*6+($LargeurPrix)/2; break;
          case "Droit" : $X=$L_Src-$Marge-($LargeurPrix)/2; break;
          case "Centre" : $X=$L_Src/2;break;
        }
    switch ($DirectionY)
        { case "Haut": $Y=$HauteurPrix/2+$Marge; break;
          case "Centre" : $Y=$H_Src/2; break;
          case "Bas" : $Y=$H_Src-$HauteurPrix/2-$Marge;break;
        }
          
      Cree_Prix($Image2,$X,$Y,$text,$Taille,"");
}      


/*----------------------------------------------------------------------------------------------------------------------
 * crée un tampon sur l'image, cad un texte encadré!
 *--------------------------------------------------------------------------------------------------------------------*/
 function Cree_Tampon($Image2,$X_Position,$Y_Position,$Texte,$Taille_Police,$Rotation)
{
	 //calcul de la taille de la boîte
    if (getenv("REMOTE_ADDR")!="127.0.0.1")
     { $extension_police=".ttf";} else {$extension_police="";} 
    putenv('GDFONTPATH=' . realpath('.'));
    $Chemin_Police="/polices";
    $font = $Chemin_Police."/".POLICE_TAMPON.$extension_police; // a remplacer par votre police    
       
    $TexteT=explode("|",$Texte);
    $NbrePhrases=count($TexteT);
    $Padding=10;
    $LargeurTexte=0;
    $HauteurTexte=0;     
    $CentreX=0;
    $CentreY=0;   
    $Epaisseur_Trait=3;
    
    for ($i=0;$i<$NbrePhrases;$i++)
    {//détermine la plus forte largeur et la hauteur du rectangle
    $Texte=$TexteT[$i];
    $size = imagettfbbox($Taille_Police,0,$font,$Texte);    
    $LargeurTemp=abs($size[0]-$size[2]);
    if ($LargeurTexte<$LargeurTemp) {$LargeurTexte=$LargeurTemp;}
    $HauteurTemp=abs($size[3]-$size[5]);
    //if ($i==0) {$HauteurTexte=$HauteurTemp*0.3;}
    $HauteurTexte=$HauteurTexte+1.2*($HauteurTemp);      
    }//fin détermination du texte
   
    $LargeurRectangle=$LargeurTexte+$Padding;
    $HauteurRectangle=$HauteurTexte+$Padding;
   
    
    //calcule maintenant pour assurer une taille vectorielle au tampon    
   
    
    //on calcule pour un triangle qui tourne en fonction
    $Points[0]=0;
    $Points[1]=0;
    $Points[2]=$LargeurRectangle;
    $Points[3]=0;
    $Points[4]=$LargeurRectangle;
    $Points[5]=$HauteurRectangle;
    $Points[6]=0;
    $Points[7]=$HauteurRectangle;
    
    
    $AngCrad = (pi() * -$Rotation) / 180;
    $XMax=0;
    $XMin=0;
    $YMax=0;
    $YMin=0;
    
    for ($i=0;$i<count($Points)/2;$i++) //tant que de points
    {    
    $X = (($Points[$i*2] - $CentreX) * cos($AngCrad) - ($Points[$i*2+1] - $CentreY) * sin($AngCrad) + $CentreX);
    //if ($X>$XMax) {$XMax=$X;}
    //if ($XMin>$X) {$XMin=$X;}
    $Y=(($Points[$i*2] - $CentreX) * sin($AngCrad) + ($Points[$i*2+1] - $CentreY) * cos($AngCrad) + $CentreY);
    //if ($Y>$YMax) {$YMax=$Y;}
    //if ($Y<$YMin) {$YMin=$Y;}
    $Points[$i*2]=$X+$X_Position;    
    $Points[$i*2+1]=$Y+$Y_Position;
    }        
    //$LargeurImage=abs($XMax)+abs($XMin);
    //$HauteurImage=abs($YMax)+abs($YMin);
   
    
    $Couleur=COULEUR_TAMPON; 
    $rouge = hexdec(substr($Couleur,0,2)); 
    $vert = hexdec(substr($Couleur,2,2));
    $bleu = hexdec(substr($Couleur,4,2));
    $Couleur1 = imagecolorallocate($Image2,$rouge,$vert,$bleu);
    
    for ($i=0;$i<$NbrePhrases;$i++) //tant que de phrases!
    {
    $Texte=$TexteT[$i];
    $size = imagettfbbox($Taille_Police,0,$font,$Texte);    
    $LargeurTemp=abs($size[0]-$size[2]);
    $X_PositionTexte=($LargeurRectangle-$LargeurTemp)/2;
    $Y_PositionTexte=$HauteurRectangle-$Padding/2-($HauteurTexte*1.2*($NbrePhrases-($i+1))/$NbrePhrases);
    //Calcul du point de départ du texte
    $X = (($X_PositionTexte - $CentreX) * cos($AngCrad) - ($Y_PositionTexte - $CentreY) * sin($AngCrad) + $CentreX)+$X_Position;
    $Y =  (($X_PositionTexte - $CentreX) * sin($AngCrad) + ($Y_PositionTexte - $CentreY) * cos($AngCrad) + $CentreY)+$Y_Position;
    ImageTTFText($Image2, $Taille_Police,$Rotation,$X, $Y, $Couleur1, $font, $TexteT[$i]);  
    }
   
    imagesetthickness ($Image2,$Epaisseur_Trait);    
    imagepolygon($Image2,$Points,intval(count($Points)/2),$Couleur1);  		
}
    
  function Cree_Cordon($Image2,$Texte,$Taille_Police,$Angle)
    {
    
    $L_Src=imagesx($Image2);
    //fixer decalage
    $Decalage=intval($L_Src/4);
    //Calculer la hauteur du texte            
    
     if (getenv("REMOTE_ADDR")!="127.0.0.1")
     { $extension_police=".ttf";} else {$extension_police="";} 
    putenv('GDFONTPATH=' . realpath('.'));
    $Chemin_Police="/polices";
    $font = $Chemin_Police."/".POLICE_BANDEAU_TRANSVERSAL.$extension_police; // a remplacer par votre police    
       
    $TexteT=explode("|",$Texte);
    $NbrePhrases=count($TexteT);
    $Padding=10;
    $LargeurTexte=0;
    $HauteurTexte=0;     
    $CentreX=0;
    $CentreY=0;   
    $Epaisseur_Trait=3;
   
    for ($i=0;$i<$NbrePhrases;$i++)
    {//détermine la plus forte largeur et la hauteur du rectangle
    $Texte=$TexteT[$i];
    $size = imagettfbbox($Taille_Police,0,$font,$Texte);    
    $LargeurTemp=abs($size[0]-$size[2]);
    if ($LargeurTexte<$LargeurTemp) {$LargeurTexte=$LargeurTemp;}
    $HauteurTemp=abs($size[3]-$size[5]);
    //if ($i==0) {$HauteurTexte=$HauteurTemp*0.3;}
    $HauteurTexte=$HauteurTexte+1.2*($HauteurTemp);      
    }//fin détermination du texte
       
    $HauteurRectangle=$HauteurTexte+$Padding;
    
    //hauteurrectangle contient la hauteur du texte
    //calcule lecompléent de chauqe cote pour fixer l'ordonnée à l'origine   
    $X_Position=0;
    $Y_Position=$Decalage+($HauteurRectangle*sin(deg2rad(90))/sin(deg2rad(90-$Angle)));  
    $LargeurRectangle=$Y_Position*sin(deg2rad(90))/sin(deg2rad($Angle));    
    $LargeurRectangle=$LargeurRectangle+$L1+$L2;
    $X_Position=-$HauteurRectangle*sin(deg2rad(90-$Angle))/sin(deg2rad(90));
    $Y_Position=$Y_Position-$HauteurRectangle*sin(deg2rad(90-$Angle))/sin(deg2rad(90));
    
    
    $Points[0]=0;
    $Points[1]=0;
    $Points[2]=$LargeurRectangle;
    $Points[3]=0;
    $Points[4]=$LargeurRectangle;
    $Points[5]=$HauteurRectangle;
    $Points[6]=0;
    $Points[7]=$HauteurRectangle;
    
    
    $Rotation=$Angle;
    $AngCrad = (pi() * -$Rotation) / 180;
    $XMax=0;
    $XMin=0;
    $YMax=0;
    $YMin=0;
    
    for ($i=0;$i<count($Points)/2;$i++) //tant que de points
    {    
    $X = (($Points[$i*2] - $CentreX) * cos($AngCrad) - ($Points[$i*2+1] - $CentreY) * sin($AngCrad) + $CentreX);
    //if ($X>$XMax) {$XMax=$X;}
    //if ($XMin>$X) {$XMin=$X;}
    $Y=(($Points[$i*2] - $CentreX) * sin($AngCrad) + ($Points[$i*2+1] - $CentreY) * cos($AngCrad) + $CentreY);
    //if ($Y>$YMax) {$YMax=$Y;}
    //if ($Y<$YMin) {$YMin=$Y;}
    $Points[$i*2]=$X+$X_Position;    
    $Points[$i*2+1]=$Y+$Y_Position;
    }        
    //$LargeurImage=abs($XMax)+abs($XMin);
    //$HauteurImage=abs($YMax)+abs($YMin);
    
    
    //le fond du bandeau
    $Couleur=COULEUR_BANDEAU_TRANSVERSAL; 
    $rouge = hexdec(substr($Couleur,0,2)); 
    $vert = hexdec(substr($Couleur,2,2));
    $bleu = hexdec(substr($Couleur,4,2));
    $Couleur1 = imagecolorallocate($Image2,$rouge,$vert,$bleu);
    imagesetthickness ($Image2,$Epaisseur_Trait);    
    imagefilledpolygon($Image2,$Points,intval(count($Points)/2),$Couleur1);  		
    
    //le texte sur le bandeau!
    $Couleur=COULEUR_TEXTE_BANDEAU_TRANSVERSAL; 
    $rouge = hexdec(substr($Couleur,0,2)); 
    $vert = hexdec(substr($Couleur,2,2));
    $bleu = hexdec(substr($Couleur,4,2));
    $Couleur1 = imagecolorallocate($Image2,$rouge,$vert,$bleu);
    
    for ($i=0;$i<$NbrePhrases;$i++) //tant que de phrases!
    {
    $Texte=$TexteT[$i];
    $size = imagettfbbox($Taille_Police,0,$font,$Texte);    
    $LargeurTemp=abs($size[0]-$size[2]);
    $X_PositionTexte=($LargeurRectangle-$LargeurTemp)/2;
    $Y_PositionTexte=$HauteurRectangle-$Padding/2-($HauteurTexte*1.2*($NbrePhrases-($i+1))/$NbrePhrases);
    //Calcul du point de départ du texte
    $X = (($X_PositionTexte - $CentreX) * cos($AngCrad) - ($Y_PositionTexte - $CentreY) * sin($AngCrad) + $CentreX)+$X_Position;
    $Y =  (($X_PositionTexte - $CentreX) * sin($AngCrad) + ($Y_PositionTexte - $CentreY) * cos($AngCrad) + $CentreY)+$Y_Position;
    ImageTTFText($Image2, $Taille_Police,$Rotation,$X, $Y, $Couleur1, $font, $TexteT[$i]);  
    }               
  }
    
/* --------------------------------------------------------------------------------------------------------------------
   Cette fonction crée un texte d'une couleur CouleurRemplissage, entouré en gras de la couleur Couleur Fond,
   Centré sur lui même sur plusieurs lignes si nécessaires. Le Texte peut être écrit obliquement.
   ------------------------------------------------------------------------------------------------------------------*/
   
 function Cree_Argument_Vente($Image,$Texte,$Taille_Police,$Rotation,$JustificationHoriz,$JustificationVert)
{
	  //$CouleurTransparente="FEFCFC";
    if (getenv("REMOTE_ADDR")!="127.0.0.1")
     { $extension_police=".ttf";} else {$extension_police="";} 
    putenv('GDFONTPATH=' . realpath('.'));
    $Chemin_Police="/polices";
    $font = $Chemin_Police."/".POLICE_ARGUMENT.$extension_police; // a remplacer par votre police    
       
    $TexteT=explode("|",$Texte);
    $NbrePhrases=count($TexteT);    
    $LargeurTexte=0;
    $HauteurTexte=0;     
    $LargeurTemp=0;
    
    for ($i=0;$i<$NbrePhrases;$i++)
    {//détermine la plus forte largeur et la hauteur du rectangle
    $Texte=$TexteT[$i];
    $size = imagettfbbox($Taille_Police,0,$font,$Texte);    
    $LargeurTemp=abs($size[0]-$size[2]);
    if ($LargeurTexte<$LargeurTemp) {$LargeurTexte=$LargeurTemp;}
    $HauteurTemp=abs($size[3]-$size[5]);
    //if ($i==0) {$HauteurTexte=$HauteurTemp*0.3;}
    $HauteurTexte=$HauteurTexte+1.2*($HauteurTemp);      
    }//fin détermination du texte
    $Padding=8;
    $LargeurTexte=$LargeurTexte+$Padding;
    $HauteurTexte=$HauteurTexte+$Padding;
   
    $Image2=Cree_Fond_Bandeau('','',$LargeurTexte,$HauteurTexte,$CouleurTransparente);	
    $X=0;
    $Y=$Taille_Police;
 
    $LargeurRectangle=imagesx($Image2);
    $HauteurRectangle=imagesy($Image2);
//cas particulier de la rotation de l'image    
if ($Rotation!=0) //alors on fait tourner l'image
   {$rouge = hexdec(substr($CouleurTransparente,0,2)); 
    $vert = hexdec(substr($CouleurTransparente,2,2));
    $bleu = hexdec(substr($CouleurTransparente,4,2));
    $CouleurTransparente1=imagecolorallocate($Image2,$rouge,$vert,$bleu);
    imagecolortransparent($Image2,$CouleurTransparente1);
   	$Image3=imagerotate($Image2,$Rotation, $CouleurTransparente1 );
   	$LargeurRectangle=imagesx($Image3);
    $HauteurRectangle=imagesy($Image3);
    imagedestroy($Image3);
   }

   
//on copie maintenant image 3 sur image
 //a ce stade image0 cntient l'encart, $LargeurRectangle et $HauteurRectangle, ses dimensions.
$ImageHauteur=imagesy($Image);
$ImageLargeur=imagesx($Image);
$Padding=10;


//on essaie nouvelle fonction
$rouge = hexdec(substr($CouleurChoisie,0,2)); 
$vert = hexdec(substr($CouleurChoisie,2,2));
$bleu = hexdec(substr($CouleurChoisie,4,2));
$Couleur1=imagecolorallocate($Image,$rouge,$vert,$bleu); 

switch ($JustificationHoriz)
  { case "Gauche" : $X_Position=$Padding+$LargeurRectangle/2;break;
    case "Centre" : $X_Position=($ImageLargeur/2);break;
    case "Droit" : $X_Position=$ImageLargeur-($LargeurRectangle/2)-$Padding; break;
    default       : break;    
  }
switch ($JustificationVert)
  { case "Haut"   : $Y_Position=$HauteurRectangle/2; break;
    case "Centre" : $Y_Position=$ImageHauteur/2;break;
    case "Bas"    : $Y_Position=$ImageHauteur-$HauteurRectangle/2-$Padding;  break;
    default       : break;    
  }  

    $rouge = hexdec(substr(COULEUR_ARGUMENT,0,2)); 
    $vert = hexdec(substr(COULEUR_ARGUMENT,2,2));
    $bleu = hexdec(substr(COULEUR_ARGUMENT,4,2));
    $Couleur1=imagecolorallocate($Image,$rouge,$vert,$bleu);
  
  
    if (COULEUR_BORD_ARGUMENT!='')
    {$rouge = hexdec(substr(COULEUR_BORD_ARGUMENT,0,2)); 
     $vert = hexdec(substr(COULEUR_BORD_ARGUMENT,2,2));
     $bleu = hexdec(substr(COULEUR_BORD_ARGUMENT,4,2));
     $Couleur2=imagecolorallocate($Image,$rouge,$vert,$bleu);
    }  
  
    $_x = array(2, 0, 2, 0, -2, -2, 2, 0, -2); 
    $_y = array(0, -2, -2, 0, 0, -2, 2, 2, 2); 
  
  
    for ($i=0;$i<$NbrePhrases;$i++)
      {         if (COULEUR_BORD_ARGUMENT!='')
              {//dessine le fond des caractères en couleur COULEURBORD ARGUMENT
               for($n=0;$n<=8;$n++) 
               { 
                $CodeErreur=Imagettftext_Cr($Image, $Taille_Police, $Rotation, $X_Position+$_x[$n], $Y_Position+$_y[$n], $Couleur2, $font, $TexteT[$i]); 
               } 
              }
        $CodeErreur=Imagettftext_Cr($Image, $Taille_Police, $Rotation, $X_Position, $Y_Position, $Couleur1, $font, $TexteT[$i]);       
        $Y_Position=$Y_Position+$Taille_Police*1.3;
        $X_Position=$X_Position+($Taille_Police*sin(deg2rad($Rotation))/sin(deg2rad(90)));
      }          	     
}   

/*--------------------------------------------------------------------------------------------------------------------
  cette fonction crée une image gif clignotante sur fond coloré avec un encadre. les différentes étapes de texte
  sont séparés par des pipes |.
  ex : $Texte="mes ventes|flash";
  si hauteur et largeur ne sont pas passés, calcule automatiquement la meilleure tzille.
  ------------------------------------------------------------------------------------------------------------------*/
function Affichette_Clignotante($LargeurRectangle,$HauteurRectangle,$Texte,$Police, $Taille_Police, $CouleurTexte,$CouleurFond,$CouleurBord)
{
//création du tableau de texte
$Tab_Texte=explode("|",$Texte);

//recherche de la plus grande largeur pour dessiner l'image
$LargeurMax=0;
$HauteurMax=0;
for ($i=0;$i<count($Tab_Texte);$i++)
{ $Dim=Dimension_Cree_Texte($Tab_Texte[$i],$Police,$Taille_Police);
  if ($Dim[0]>$LargeurMax) {$LargeurMax=$Dim[0];}  
  if ($Dim[1]>$HauteurMax) {$HauteurMax=$Dim[1];}
}
$Padding=$Taille_Police*0.3;
if ($LargeurMax>$LargeurRectangle) {$LargeurRectangle=$LargeurMax+$Padding*2;}
if ($HauteurMax>$HauteurRectangle) {$HauteurRectangle=$HauteurMax+$Padding*2;}
//definition de la couleur de fond
$rouge = hexdec(substr($CouleurBord,0,2)); 
$vert = hexdec(substr($CouleurBord,2,2));
$bleu = hexdec(substr($CouleurBord,4,2));

   for ($i=0;$i<count($Tab_Texte);$i++)
   {
   //cree l'image
   $Tab_Image[$i]=Cree_Fond_Bandeau('','',$LargeurRectangle,$HauteurRectangle,$CouleurFond);	
   //ecrit le texte dessus
   Cree_Texte($Tab_Image[$i],0,0,$LargeurRectangle,$HauteurRectangle,$Tab_Texte[$i],$Police,$Taille_Police,$CouleurTexte,"Centre","Centre");
   //dessine le rectangle sur l'image
   $CouleurBord0 = imagecolorallocate($Tab_Image[$i],$rouge,$vert,$bleu);  
   imagerectangle ($Tab_Image[$i], 0, 0, $LargeurRectangle-1, $HauteurRectangle-1, $CouleurBord0); 
   ob_start();
   imagegif($Tab_Image[$i]);
   $frames[$i] = ob_get_contents();
   ob_end_clean(); 
   //gestion des délais divers
   $__d[$i]=90;
   $__x[$i]=0;
   $__y[$i]=0;  
	 }

$gifmerge	= new GifMerge($frames, '', '','', -10, $__d, 2, $__x, $__y, 'C_MEMORY');

echo $gifmerge -> getAnimation();
}


/*-------------------------------------------------------------------------------------------------------------------
 Cette fonction récupère les images passées dans le tableau $Tab_Image et en crée une image gif anmée
 Les images doivent toutes être ouvertes par imagecreatefromgif ou imagecreatetruecolor.
 Elles doivent également êre toutes de la même couleur
 $Delai déigne le temps séparant chaque image
 $DernierDelai designe le temps entre la fin de l'animation et son renouvellement, c'est cmme un teps
 de pause
 ------------------------------------------------------------------------------------------------------------------*/
 function Cree_Gif_Anime($Tab_Image,$Delai,$DernierDelai)
 { //valeur par defaut du delai normal
 	 if (!isset($Delai) or $Delai==0) {$Delai=50;}
 	for ($i=0;$i<count($Tab_Image);$i++)
 	  { 
 	  	//tant que d'images
 	    ob_start();
      imagegif($Tab_Image[$i]);
      $frames[$i] = ob_get_contents();
      ob_end_clean(); 
      //gestion des délais divers
      if (!isset($Delai) or $Delai==0) {$__d[$i]=50;} else {$__d[$i]=$Delai;}
      $__x[$i]=0;
      $__y[$i]=0;  
 	    }
 	//gestion de la pause par defaut
 	if (!isset($DernierDelai) or $DernierDelai==0) {$DernierDelai=$Delai;}
 	//gestion de la pause
 	$__d[count($Tab_Image)-1]=$DernierDelai;
 	//creation du gif animé
 	$gifmerge	= new GifMerge($frames, '', '','', -10, $__d, 2, $__x, $__y, 'C_MEMORY');
  echo 		$gifmerge -> getAnimation();     	 	
 }

/*-----------------------------------------------------------------------------------------------------------------
 cette fonction crée un encadré des prix avec le prix normal barré et le prix nouveau en plus gros.
 un message peut être diffusé en dessous
 ----------------------------------------------------------------------------------------------------------------*/
 function Cree_Encart_Prix($Image,$Prix_Normal,$Prix_Rabais,$Commentaire,$JustificationHoriz,$JustificationVert)
{
//recherche de la plus grande largeur pour dessiner l'image
$LargeurMax=0;
$HauteurMax=0;
if (isset($Prix_Normal) && $Prix_Normal>0)
{
$Dim=Dimension_Cree_Texte($Prix_Normal,POLICE_PRIXNORMAL,TAILLE_POLICE_PRIX_NORMAL);
$Padding=TAILLE_POLICE_PRIX_NORMAL;
$LargeurPrixNormal=$Dim[0]+$Padding;;  
$HauteurPrixNormal=$Dim[1]+$Padding;
} else {$LargeurPrixNormal=0;
        $HauteurPrixNormal=0;}

//Recherche hauteur largeur prix rabais
if (isset($Prix_Rabais) && $Prix_Rabais>0)
{
$Dim=Dimension_Cree_Texte($Prix_Rabais,POLICE_PRIXRABAIS,TAILLE_POLICE_PRIX_RABAIS);
$Padding=TAILLE_POLICE_PRIX_RABAIS;
$LargeurPrixRabais=$Dim[0]+$Padding;;  
$HauteurPrixRabais=$Dim[1]+$Padding;
} else {$LargeurPrixRabais=0;
        $HauteurPrixRabais=0;
	     }	     
//on retient les plus grandes des deux hauteurs, en fonction des polices choisies
if ($HauteurPrixNormal>$HauteurPrixRabais) {$HauteurPrixRabais=$HauteurPrixNormal;}
                                    else   {$HauteurPrixNormal=$HauteurPrixRabais;}
                                    
//recherche de la largeur du commentaire
if (strlen($Commentaire)>10)
     {$Taille_PoliceCommentaire=TAILLE_POLICECOMMENTAIRE*10/(strlen($Commentaire)/1.5);
     } else {$Taille_PoliceCommentaire=TAILLE_POLICECOMMENTAIRE;}
     
$Dim=Dimension_Cree_Texte($Commentaire,POLICE_COMMENTAIRE,$Taille_PoliceCommentaire);
$Padding=$Taille_PoliceCommentaire;
$LargeurCommentaire=$Dim[0]+$Padding;;  
$HauteurCommentaire=$Dim[1]+$Padding;

                                    
//definition de la taille de l'image totale
$LargeurRectangle=$LargeurPrixNormal+$LargeurPrixRabais;
if ($LargeurCommentaire<$LargeurRectangle) {$LargeurCommentaire=$LargeurRectangle;}
                                       else {$LargeurRectangle=$LargeurCommentaire;
                                             //recalcul des largeurs des deux autres cadres du dessus                                             
                                             $LargeurPrixRabais=$LargeurRectangle-$LargeurPrixNormal;
                                             if (!isset($Prix_Rabais) or $Prix_Rabais==0)  
                                                      {$LargeurPrixNormal=$LargeurRectangle;}                                         
                                             }
$HauteurRectangle=$HauteurPrixNormal+$HauteurCommentaire;

//création de l'image support
$CouleurTransparente="FEFCFC";
$Image0=Cree_Fond_Bandeau('','',$LargeurRectangle,$HauteurRectangle,$CouleurTransparente);	

if (isset($Prix_Normal) && $Prix_Normal>0)
{
//creation de l'image du prix normal
if ($Prix_Rabais==0 or !isset($Prix_Rabais)) 
                 {$Image1=Cree_Fond_Bandeau('','',$LargeurPrixNormal,$HauteurPrixNormal,COULEURFOND_UNSEULPRIX);}
            else {$Image1=Cree_Fond_Bandeau('','',$LargeurPrixNormal,$HauteurPrixNormal,COULEURFOND_PRIXNORMAL);	}
//on dessine le rectangle du prix normal avec son fond
$rouge = hexdec(substr(COULEURBORD_PRIXNORMAL,0,2)); 
$vert = hexdec(substr(COULEURBORD_PRIXNORMAL,2,2));
$bleu = hexdec(substr(COULEURBORD_PRIXNORMAL,4,2));
$CouleurPrixNorm_Bord = imagecolorallocate($Image1,$rouge,$vert,$bleu);  
imagerectangle ($Image1, 0, 0, $LargeurPrixNormal-1, $HauteurPrixNormal-1, $CouleurPrixNorm_Bord);
//on ecrit le prix dessus
if ($Prix_Rabais==0 or !isset($Prix_Rabais)) 
     {Cree_Texte($Image1,0,0,$LargeurPrixNormal,$HauteurPrixNormal,$Prix_Normal,POLICE_PRIXRABAIS,TAILLE_POLICE_PRIX_RABAIS,COULEURFOND_PRIXRABAIS,"Centre","Centre");}
     else {Cree_Texte($Image1,0,0,$LargeurPrixNormal,$HauteurPrixNormal,$Prix_Normal,POLICE_PRIXNORMAL,TAILLE_POLICE_PRIX_NORMAL,COULEURPOLICE_PRIXNORMAL,"Centre","Centre");}
if ((isset($Prix_Rabais) && $Prix_Rabais!=0)) 
{
//on trace le trait qui barre le prix normal
/*
if ($Prix_Rabais=="0.00" or $Prix_Rabais=="0,00")
    { 
      $rouge = hexdec(substr(COULEURFOND_PRIXRABAIS,0,2)); 
      $vert = hexdec(substr(COULEURFOND_PRIXRABAIS,2,2));
      $bleu = hexdec(substr(COULEURFOND_PRIXRABAIS,4,2));
      $CouleurPrixNorm_Bord = imagecolorallocate($Image1,$rouge,$vert,$bleu);  
      imagesetthickness($Image1,2);
      imageline($Image1,0,0,$LargeurPrixNormal,$HauteurPrixNormal,$CouleurPrixNorm_Bord);
    }
    else {imagesetthickness($Image1,4);}
*/

imagesetthickness($Image1,4);
imageline($Image1,0,$HauteurPrixNormal,$LargeurPrixNormal,0,$CouleurPrixNorm_Bord);
}
imagecopy($Image0,$Image1,$LargeurRectangle-$LargeurPrixNormal,0,0,0,$LargeurPrixNormal,$HauteurPrixNormal);
imagedestroy($Image1);
}

if (isset($Prix_Rabais) && $Prix_Rabais>0)
{
//creation de l'image du prix rabais
if ($Prix_Normal==0 or !isset($Prix_Normal)) {$Image2=Cree_Fond_Bandeau('','',$LargeurPrixRabais,$HauteurPrixRabais,COULEURFOND_UNSEULPRIX);}
          else {$Image2=Cree_Fond_Bandeau('','',$LargeurPrixRabais,$HauteurPrixRabais,COULEURFOND_PRIXRABAIS);	}
//on dessine le rectangle du prix normal avec son fond
$rouge = hexdec(substr(COULEURBORD_PRIXRABAIS,0,2)); 
$vert = hexdec(substr(COULEURBORD_PRIXRABAIS,2,2));
$bleu = hexdec(substr(COULEURBORD_PRIXRABAIS,4,2));
$CouleurPrixRabais_Bord = imagecolorallocate($Image2,$rouge,$vert,$bleu);  
imagerectangle ($Image2, 0, 0, $LargeurPrixRabais-1, $HauteurPrixRabais-1, $CouleurPrixRabais_Bord); 
//on trace le trait qui barre le prix normal
//on ecrit le prix dessus
if ($Prix_Normal==0 or !isset($Prix_Normal))
     {Cree_Texte($Image2,0,0,$LargeurPrixRabais,$HauteurPrixRabais,$Prix_Rabais,POLICE_PRIXRABAIS,TAILLE_POLICE_PRIX_RABAIS,COULEURFOND_PRIXRABAIS,"Centre","Centre");}
     else {Cree_Texte($Image2,0,0,$LargeurPrixRabais,$HauteurPrixRabais,$Prix_Rabais,POLICE_PRIXRABAIS,TAILLE_POLICE_PRIX_RABAIS,COULEURPOLICE_PRIXRABAIS,"Centre","Centre");}
imagecopy($Image0,$Image2,$LargeurRectangle-$LargeurPrixRabais-$LargeurPrixNormal,0,0,0,$LargeurPrixRabais,$HauteurPrixRabais);
imagedestroy($Image2);
}

//creation de l'image du commentaire
$Image3=Cree_Fond_Bandeau('','',$LargeurCommentaire,$HauteurCommentaire,COULEURFOND_COMMENTAIRE);	
//on ecrit le commentaire centré
Cree_Texte($Image3,0,0,$LargeurCommentaire,$HauteurCommentaire,$Commentaire,POLICE_COMMENTAIRE,$Taille_PoliceCommentaire,COULEURPOLICE_COMMENTAIRE,"Centre","Centre");

//on recopie cette image sur l'image de fond globale
imagecopy($Image0,$Image3,0,$HauteurPrixNormal,0,0,$LargeurCommentaire,$HauteurCommentaire);
imagedestroy($Image3);
//a ce stade image0 cntient l'encart, $LargeurRectangle et $HauteurRectangle, ses dimensions.
$ImageHauteur=imagesy($Image);
$ImageLargeur=imagesx($Image);
$Padding=10;
switch ($JustificationHoriz)
  { case "Gauche" : $X_Position=$Padding;break;
    case "Centre" : $X_Position=($ImageLargeur-$LargeurRectangle)/2;break;
    case "Droit" : $X_Position=$ImageLargeur-$LargeurRectangle-$Padding; break;
    default       : break;    
  }
switch ($JustificationVert)
  { case "Haut"   : $Y_Position=$Padding; break;
    case "Centre" : ($ImageHauteur-$HauteurRectangle)/2;break;
    case "Bas"    : $Y_Position=$ImageHauteur-$HauteurRectangle-$Padding;  break;
    default       : break;    
  }  
//pose la transparence du fond blanc

$rouge = hexdec(substr($CouleurTransparente,0,2)); 
$vert = hexdec(substr($CouleurTransparente,2,2));
$bleu = hexdec(substr($CouleurTransparente,4,2));
$CouleurTransparente1=imagecolorallocate($Image0,$rouge,$vert,$bleu);
imagecolortransparent($Image0,$CouleurTransparente1);

imagecopymerge($Image,$Image0,$X_Position,$Y_Position,0,0,$LargeurRectangle,$HauteurRectangle,100);
imagedestroy($Image0);

}

/*-----------------------------------------------------------------------------------------------------------------
 cette fonction cree un argumentaire en majuscules sur deux lignes

 la première ligne est d'une couleur, la seconde d'une autre
 les eux phrases sont passées par le pipe $Texte="phrase1|$Phrase2";
 ----------------------------------------------------------------------------------------------------------------*/
  function Cree_Argument_Vente_Couleurs($Image,$Texte,$Taille_Police,$Rotation,$JustificationHoriz,$JustificationVert)
{
//$CouleurTransparente="FEFCFC";
    if (getenv("REMOTE_ADDR")!="127.0.0.1")
     { $extension_police=".ttf";} else {$extension_police="";} 
    putenv('GDFONTPATH=' . realpath('.'));
    $Chemin_Police="/polices";
    $font = $Chemin_Police."/".POLICE_ARGUMENT.$extension_police; // a remplacer par votre police    
       
    $TexteT=explode("|",$Texte);
    $NbrePhrases=count($TexteT);    
    $LargeurTexte=0;
    $HauteurTexte=0;     
    $LargeurTemp=0;
    
    for ($i=0;$i<$NbrePhrases;$i++)
    {//détermine la plus forte largeur et la hauteur du rectangle
    $Texte=strtoupper($TexteT[$i]);
    $size = imagettfbbox($Taille_Police,0,$font,$Texte);    
    $LargeurTemp=abs($size[0]-$size[2]);
    if ($LargeurTexte<$LargeurTemp) {$LargeurTexte=$LargeurTemp;}
    $HauteurTemp=abs($size[3]-$size[5]);
    //if ($i==0) {$HauteurTexte=$HauteurTemp*0.3;}
    $HauteurTexte=$HauteurTexte+1.2*($HauteurTemp);      
    }//fin détermination du texte
    $Padding=8;
    $LargeurTexte=$LargeurTexte+$Padding;
    $HauteurTexte=$HauteurTexte+$Padding;
   
    $Image2=Cree_Fond_Bandeau('','',$LargeurTexte,$HauteurTexte,"000000");	
   
 
    $LargeurRectangle=imagesx($Image2);
    $HauteurRectangle=imagesy($Image2);
//cas particulier de la rotation de l'image    
if ($Rotation!=0) //alors on fait tourner l'image
   {   
   	$Image3=imagerotate($Image2,$Rotation, 0 );
   	$LargeurRectangle=imagesx($Image3);
    $HauteurRectangle=imagesy($Image3);
    imagedestroy($Image3);
   }
   
//on copie maintenant image 3 sur image
 //a ce stade image0 cntient l'encart, $LargeurRectangle et $HauteurRectangle, ses dimensions.
$ImageHauteur=imagesy($Image);
$ImageLargeur=imagesx($Image);
$Padding=10;

switch ($JustificationHoriz)
  { case "Gauche" : $X_Position=$Padding+$LargeurRectangle/2;break;
    case "Centre" : $X_Position=($ImageLargeur/2);break;
    case "Droit" : $X_Position=$ImageLargeur-($LargeurRectangle/2)-$Padding; break;
    default       : break;    
  }
switch ($JustificationVert)
  { case "Haut"   : $Y_Position=$HauteurRectangle/2; break;
    case "Centre" : $Y_Position=($ImageHauteur)/2;break;
    case "Bas"    : $Y_Position=$ImageHauteur-$HauteurRectangle/2-$Padding;  break;
    default       : break;    
  }  

    $rouge = hexdec(substr(COULEUR_ARGUMENT,0,2)); 
    $vert = hexdec(substr(COULEUR_ARGUMENT,2,2));
    $bleu = hexdec(substr(COULEUR_ARGUMENT,4,2));
    $Couleur1=imagecolorallocate($Image,$rouge,$vert,$bleu);
    
    $rouge = hexdec(substr(COULEUR_ARGUMENT2,0,2)); 
    $vert = hexdec(substr(COULEUR_ARGUMENT2,2,2));
    $bleu = hexdec(substr(COULEUR_ARGUMENT2,4,2));
    $Couleur3=imagecolorallocate($Image,$rouge,$vert,$bleu);
  
    if (COULEUR_BORD_ARGUMENT!='')
    {$rouge = hexdec(substr(COULEUR_BORD_ARGUMENT,0,2)); 
     $vert = hexdec(substr(COULEUR_BORD_ARGUMENT,2,2));
     $bleu = hexdec(substr(COULEUR_BORD_ARGUMENT,4,2));
     $Couleur2=imagecolorallocate($Image,$rouge,$vert,$bleu);
    }  
  
    $_x = array(2, 0, 2, 0, -2, -2, 2, 0, -2); 
    $_y = array(0, -2, -2, 0, 0, -2, 2, 2, 2); 
  
  
    for ($i=0;$i<$NbrePhrases;$i++)
      {         if (COULEUR_BORD_ARGUMENT!='')
              {//dessine le fond des caractères en couleur COULEURBORD ARGUMENT
               for($n=0;$n<=8;$n++) 
               { 
                $CodeErreur=Imagettftext_Cr($Image, $Taille_Police, $Rotation, $X_Position+$_x[$n], $Y_Position+$_y[$n], $Couleur2, $font, strtoupper($TexteT[$i])); 
               } 
              }
        if (rand(0,1)==0)
           {$CodeErreur=Imagettftext_Cr($Image, $Taille_Police, $Rotation, $X_Position, $Y_Position, $Couleur1, $font, strtoupper($TexteT[$i]));       
             }
           else {$CodeErreur=Imagettftext_Cr($Image, $Taille_Police, $Rotation, $X_Position, $Y_Position, $Couleur3, $font, strtoupper($TexteT[$i]));       
                }
        $Y_Position=$Y_Position+$Taille_Police*1.3;
        $X_Position=$X_Position+($Taille_Police*sin(deg2rad($Rotation))/sin(deg2rad(90)));
      }          	            	     
	
	 
}   


?>