Guide Rapide

sorties Vod, Dvd, Blu‑Ray

Ils jouent dans des films, ce soir à la télé :
20h55
André Wilms
André Wilms
20h55
Benoît Poelvoorde
Benoît Poelvoorde

Du texte sur des images: les photos taguées "abaca"

Les photos ont été taggées automatiquement grâce à un programme php conçu par le Guide Rapide. Le programme transforme le texte "abaca" en image puis vient le coller sur la photo avec deux effets:
- antialiasing, pour que l'intégration soit parfaite dans un détourage progressif
- et légère transparence, afin que la couleur du tag ( le blanc ) prenne une teinte adaptée à la photo.
Pour les programmeurs, vous pouvez lire les quelques indications techniques en dessous des photos d'exemple (voir bas de page).
Niels Arestrup

Helene Vincent

Frank Langella

Gérard Lanvin

Richard Berry

Noémie Lvovsky

Thierry Lhermitte

Claude Piéplu

Josiane Balasko

Christian Clavier

Gérard Jugnot

Luis Rego

Pour écrire du texte sur une image, php propose deux fonctions:
- imagestring()
- et imagettftext()


imagestring() est une fonction très limitée, car elle ne propose que 5 tailles pour la police et il n'est donc pas possible d'écrire notre texte en gros sur l'image.
imagettftext() est une fonction très intéressante.
elle permet notamment d'écrire avec n'importe quelle fonte, il suffit de mettre le fichier fonte.ttf dans un dossier et de faire appel à ce fichier dans la fonction, fonction qui va donc écrire un texte sur votre photo en utilisant les caractères trouvés dans le fichier fonte.ttf ( par exemple arial.ttf ).
Vous pouvez régler la taille des caractères à votre guise.
Et vous pouvez même donner un angle à votre texte, qui pourra donc être horizontal, de biais, vertical...


Mais comme pour le site Guide Rapide, rien n'est trop beau, une fonction spéciale a été créée afin d'avoir un rendu le plus artistique possible, c'est à dire en réalité que le texte ajouté sur l'image s'y intègre de façon la plus discrète possible, tout en restant parfaitement visible.
Deux objectifs antinomiques, mais bref passons.
Il a donc été décidé que le texte serait doté d'un effet de transparence.



Le principe pour obtenir cet effet de transparence est le suivant:

On va regarder pixel par pixel de l'image où l'on veut écrire le texte, et on va éclaircir les pixels qui correspondent à l'endroit où on veut voir apparaître ce texte. On n'attribue donc pas une couleur fixe à ces pixels. La couleur attribuée aux pixels concernés, sera obtenue en augmentant les données ( rouge, vert, bleu ) de la couleur d'origine.


Deuxième grand principe:
avant d'écrire une lettre du texte sur l'image à taguer, on inspecte la zone pour savoir quelle est sa luminosité. En fait on vérifie qu'elle n'est pas trop claire. Et si c'est le cas, au lieu de créer une lettre par éclaircissement, on la créera par obscurcissement.


Troisième grand principe:
les couleurs du masque qui ne sont ni noires ni blanches et correspondent donc à l'alliasing, seront utilisées pour définir un éclaircissement intermédiaire des pixels sur l'image à tagger, afin d'obtenir aussi un alliasing sur le texte qui sera tagué sur l'image.



Les différentes étapes du programme:

- première étape: créer une image, appellée "le masque", sur laquelle on écrit le texte en noir sur blanc, avec la taille voulue. L'antialising ne doit pas être débranché.
- deuxième étape: on analyse le masque. Cette analyse conduit à établir les coordonnées des différentes lettres composant le texte ( et donc le masque ). Ces coordonnées seront utilisées pour faire des diagnostics sur l'image à tagger, afin d'établir si les lettres doivent être obtenues par éclaircissement de l'image originale ou bien par obscurcissement.
- troisième étape: on écrit le texte sur l'image, en prenant comme "patron" le masque que l'on a créé. On parcourt les pixels du masque et si la couleur est blanche ( couleur de fond ), on ne fait rien, et si la couleur est noire, on applique un éclaircissement au pixel de l'image à tagger. Si la couleur est grise, on applique un éclaircissement intermédiaire.




Détail intéressant:

Il sera extrêmement simple de faire fonctionner ce programme pour qu'il taggue non pas un texte sur une photo, mais un vrai logo ( un dessin ). Il vous suffira d'avoir ce dessin en noir et blanc, et le code ci-dessous sera quasimment instantanément exploitable pour faire le tag du logo sur votre image d'origine.



Remarque: le programme ci-dessous marche, puisqu'il a permis de créer les texte "abacca" que vous pouvez voir sur les photos ci-dessus. Mais il n'a pas été commenté pour que vous puissiez le lire comme un vrai tutoriel. Les commentaires sont ceux écrits par le programmeur lors de la création du programme et ne sont pas forcément très compréhensibles...
Néanmoins, si les principes du programme ont été suffisamment bien expliqués, vous n'aurez qu'à piocher les quelques éléments techniques qui vous manquent pour réécrire votre propre programme.
Vous pouvez aussi l'utiliser tel quel, même sans tout comprendre. Il vous faudra juste régler le chemin d'accès vers le fichier à traiter et donner un chemin de sortie adéquat.






Ce programme est libre de droits:

Vous pouvez le réutiliser à votre guise, pour tout usage qu'il vous plaira.
Mais un lien de remerciement vers ce site sera bien sûr apprécié !


<?php
 
echo 'commencé à '.date('H:i:s').'<br /><br />';
 
 
 
$tem_new = true ; // si on met cette option à true, seuls les photos non taggées seront alors prises en compte
 
 
$text = 'abaca' ; // le tag qu'on veut mettre sur la photo
$taille_fonte = 35 ; //bonard: 40
 
 
$opacite_init = 40 ; //sur 100 : définit le degre d'opacité du marquage des lettres ( très opaque = blanc ) //bonard: 50
 
 
 
$fonte = 'antique_olive' ; // antique_olive arial impact arial_bold // voir http://www.fontyukle.net/fr/list-hit,1
$antialiasing = true ; // j'utilise la fonte antialiasée ou pas
 
 
$marge_tag_x = 4 ; // les marges qui sont entre le tag et les bords de l'image
// dans le cas d'un sens horizontal, cette première marge représente l'ecart entre la fin du mot et le bord droit et la deuxième marge représente l'ecart entre le bas du texte et le bord inférieur
// dans le cas d'un sens vertical, la première marge représente l'écart entre le bas du texte et le bord droit et la deuxième marge représente l'ecart entre le début du mot et le bord du bas.
$marge_tag_y = 5 ;
 
 
$limite_luminosite_init = 210 ; // au delà, on bascule dans l effet inverse: on obsurcit les lettres au lieu de les eclaircir
// pour le calcul de la luminosité, on prend simplement: rouge + vert + bleu / 3, donc $limite_luminosite vaut au maximum 255
$coeff_opacite = 3 ; // lorsque la zone est très claire, je passe en marquage par obscurssissement, mais je peux ici régler l'importance de l'obscurcissement
 
 
 
 
// j'ai fait cette fonction pour augmenter la clarification plus la clarete de base est grande
// en fait, je me suis demandé si c'était bien judicieux de faire tout ce bins, mais finalement, c'est bien, car si je fais comme au début, ou j'augmente la clarté des lettres à écrire, simplement en additionnant une constante pour chaque r, g et b, cela va me faire des distortions de couleurs. En faisant une formule qui tient compte de $r, $g, et $b, j'aurais une couleur éclaircie dans la vraie teinte de base.
// par contre, je trouve que ça éclairci trop quand on a une couleur de base à éclaircir qui est sombre, et ça éclaircit pas assez quand on a une couleur de base qui est claire. D'où le bins ci-dessous.
function correctif($clarete)
{
if ( $clarete >= 170 and $clarete < 180 ) { return 1.05 ; }
else if ( $clarete >= 180 and $clarete < 190 ) { return 1.1 ; }
else if ( $clarete >= 190 and $clarete < 200 ) { return 1.15 ; }
else if ( $clarete >= 200 ) { return 1.2 ; }
 
else if ( $clarete >= 90 and $clarete < 170 ) { return 1 ; }
else if ( $clarete >= 25 and $clarete < 90 ) { return 0.9 ; }
else if ( $clarete < 25 ) { return 0.8 ; }
}
 
 
 
 
 
 
 
 
 
 
 
 
///////////////////////////////////////////////////////////////////////////////
// CREATION d'une IMAGE AVEC LE TEXTE EN NOIR SUR FOND BLANC = MON MASQUE //
///////////////////////////////////////////////////////////////////////////////
 
//création d'une image vide
$largeur_vide = 500 ;
$hauteur_vide = floor($taille_fonte * 1.2) ;
$image_vide = imagecreatetruecolor($largeur_vide, $hauteur_vide) ;
//$vert = imagecolorallocate($image_vide, 0, 255, 0);
 
//curieusement, avec le php, on crée une couleur en l'associant au moment de sa création à une image.
$blanc = imagecolorallocate($image_vide, 255, 255, 255); //cette ligne permet de mettre l'image crée en couleur blanche, car le premier imagecolorallocate fait cela ( du moins je crois si on a fait appel à imagecreate et non imagecreatetruecolor
$noir = imagecolorallocate($image_vide, 1, 1, 1); // la deuxième fois qu'on utilise la fonction imagecolorallocate on ne touche plus à la couleur de fond de l'image.
 
 
//mettre cette image tout en blanc
for ( $x = 0; $x < $largeur_vide ; $x++ )
{
for ( $y = 0; $y < $hauteur_vide ; $y++ )
{
imagesetpixel($image_vide, $x, $y, $blanc) ;
}
}
 
// j'écris dans mon image: "abaca"
if ( $antialiasing == false )
{
$noir = -1 * $noir ; // cette ligne permet de rendre la valeur négative, ce qui par la suite, dans imagettftext enlève l'antialising
}
// ça me paraît mieux de travailler sans antialising pour le transparent.
//imagestring($image_vide, 5, 2, 2, 'abaca', $noir); // => NE FONCTIONNE PAS COMME JE VEUX ( taille la plus grande: 5 pixels )
 
// je suis donc obligé d'utiliser des fontes
// ( image à traiter, taille police, , x_point_bas_gauche , y_point_bas_gauche, fonte, texte )
$dimensions = imagettftext ( $image_vide, $taille_fonte , 0 , 0 , floor($taille_fonte*1.1) , $noir , 'z/'.$fonte.'.ttf' , $text ) ; // antique_olive.ttf //arial.ttf impact
 
 
 
$fichier_sortie = 'masque_non_detoure.jpg' ;
imagejpeg( $image_vide, $fichier_sortie, 100);
 
 
 
//je regarde pixel par pixel pour savoir les lignes qui sont tout en blanc et celles qui ne le sont pas
 
$y = 0 ;
$tem_noir_atteint = false ;
$hauteur_destination = 0 ;
while ( $y < $hauteur_vide ) //j'ausculte ligne par ligne
{
$tem_blanc = true ;
for ( $x = 0; $x < $largeur_vide; $x++ )
{
$rgb = imagecolorat ( $image_vide , $x , $y ) ;
$r_masque = ($rgb >> 16) & 0xFF;
$g_masque = ($rgb >> 8) & 0xFF;
$b_masque = $rgb & 0xFF;
 
if ( $r_masque != 255 or $g_masque != 255 or $b_masque != 255 ) { $tem_blanc = false ; }
}
 
if ($tem_blanc == false and $tem_noir_atteint == false ) { $y_debut = $y ; $tem_noir_atteint = true ; }
if ($tem_blanc == false ) { $hauteur_destination++ ; }
 
 
$y++ ; //passage à la ligne suivante
}
 
 
//pour l 'axe des y , faut faire autrement
$x = 0 ;
while ( $x < $largeur_vide ) //j'ausculte colonne par colonne
{
$tem_blanc = true ;
for ( $y = 0; $y < $hauteur_vide; $y++ )
{
$rgb = imagecolorat ( $image_vide , $x , $y ) ;
$r_masque = ($rgb >> 16) & 0xFF;
$g_masque = ($rgb >> 8) & 0xFF;
$b_masque = $rgb & 0xFF;
 
if ( $r_masque != 255 or $g_masque != 255 or $b_masque != 255 ) { $tem_blanc = false ; }
}
 
if ($tem_blanc == false ) { $x_debut = $x ; break ; }
 
$x++ ; //passage à la colonne suivante
}
 
//on parcours l'image en partant de la droite cette fois ci
for ( $x = $largeur_vide - 1 ; $x >= 0 ; $x = $x -1 )
{
$tem_blanc = true ;
for ( $y = 0; $y < $hauteur_vide; $y++ )
{
$rgb = imagecolorat ( $image_vide , $x , $y ) ;
$r_masque = ($rgb >> 16) & 0xFF;
$g_masque = ($rgb >> 8) & 0xFF;
$b_masque = $rgb & 0xFF;
 
if ( $r_masque != 255 or $g_masque != 255 or $b_masque != 255 ) { $tem_blanc = false ; }
}
 
if ($tem_blanc == false ) { $x_fin = $x ; break ; }
}
$largeur_destination = $x_fin - $x_debut +1 ;
 
 
 
 
 
 
// création du masque
$masque = imagecreatetruecolor($largeur_destination, $hauteur_destination); // On crée l'image vide
 
imagecopyresampled($masque, $image_vide, 0, 0, $x_debut, $y_debut, $largeur_destination, $hauteur_destination, $largeur_destination, $hauteur_destination);
 
 
 
$fichier_sortie = 'masque.jpg' ;
imagejpeg( $masque, $fichier_sortie, 100);
 
 
//exit() ;
 
 
 
 
 
 
 
 
//////////////////////////////////////////// SCAN de tous les acteurs pour reperer les images provenant d'ABACA et les tagger ////////////////////////////////////////////////////////////////////////////////////////////////////
 
$serveur = 'localhost' ;
$base_donnees = 'ma_base_de_donnees' ;
$login = 'login' ;
$mot_de_passe = 'mot_de_passe' ;
 
$bdd = new PDO('mysql:host='.$serveur.';dbname='.$base_donnees, $login, $mot_de_passe);
$bdd->query("SET NAMES UTF8") ;
 
 
 
$requete = "SELECT * FROM table_des_acteurs WHERE copyright LIKE '%abaca%' AND nom_image != '' ";
$reponse = $bdd->query($requete) ;
while ( $donnees = $reponse->fetch() )
{
 
$nom_image = $donnees['nom_image'] ;
$info_suppl = $donnees['info_suppl'] ;
 
//je vérifie que l'acteur a le même opacité de taggage que les autres ( parfois il vaut mieux augmenter l'opacité, sur les robles à fleurs par exemple )
if ( preg_match('#opacite#', $info_suppl) )
{
$value = preg_match('#opacite_([0-9]{2})#', $info_suppl, $res) ;
if ( $value == false ) { $opacite = $opacite_init ; } else { $opacite = $res[1] ; }
}
else
{ $opacite = $opacite_init ; }
 
 
 
//je vérifie que l'acteur a le même seuil de bascule du clair vers l'obscurcissement que les autres ( parfois la photot est très claire, il faut mieux tagger en obscur )
if ( preg_match('#limite_luminosite#', $info_suppl) )
{
$value = preg_match('#limite_luminosite_([0-9]{1,3})#', $info_suppl, $res) ;
if ( $value == false ) { $limite_luminosite = $limite_luminosite_init ; } else { $limite_luminosite = $res[1] ; }
}
else
{ $limite_luminosite = $limite_luminosite_init ; }
 
 
 
 
 
/////////// SENS DU TAGGAGE : HORIZONTAL OU VERTICAL ////////////////////
 
if ( preg_match('#horizontal#', $info_suppl) ) { $sens = 'horizontal' ; } else { $sens = 'vertical' ; }
//$sens = 'horizontal' ;
 
$value = preg_match('#^(.)#', $donnees['nom_image'], $res) ;
$dossier = strtolower_utf8($res[1]) ; //strtolower_utf8 est une fonction "maison" // il se trouve que les images sont rangées simplement dans un dossier qui a une seule lettre: la première du nom de l'acteur. par exemple: b/brad_pitt.jpg
$chemin = $dossier.'/'.$nom_image.'.jpg' ;
 
 
if ( $tem_new == true )
{
//dans le cas où ne veut tagger que les photos qui n'ont pas encore été taggées, on regarde si le fichier en -abaca.jpg existe
if ( file_exists($dossier.'/'.$nom_image.'-abaca.jpg') ) { continue ; }
}
 
 
 
 
 
 
 
 
 
////////////////// ECRIRE SUR MON IMAGE qu'il faut tagger ///////////////////////
 
//ouvrir l'image à tagger
$img_source = imagecreatefromjpeg($chemin) ;
$largeur_source = imagesx($img_source);
$hauteur_source = imagesy($img_source);
 
//alors on va faire ceci: pour chaque lettre du mot à tagger, on va regarder si la moyenne de couleur de l'espace sur lequel on vient tagger n'est pas trop élevé. Si oui, et bien alors on ne fait pas un éclairssissement, mais un obscurssissement
 
 
 
 
 
 
//calcul des abscisses de début de lettres
 
$largeur_masque = $largeur_destination ;
$hauteur_masque = $hauteur_destination ;
 
$decoupe = array() ; // on va mettre là-dedans toutes les abscisses de début de lettre
$decoupe[] = 0 ;
 
$x = 0 ;
$tem_noir = true ;
 
while ( $x < $largeur_masque ) //j'ausculte colonne par colonne
{
$tem_blanc = true ;
for ( $y = 0; $y < $hauteur_masque; $y++ )
{
$rgb = imagecolorat ( $masque , $x , $y ) ;
$r_masque = ($rgb >> 16) & 0xFF;
$g_masque = ($rgb >> 8) & 0xFF;
$b_masque = $rgb & 0xFF;
 
if ( $r_masque != 255 or $g_masque != 255 or $b_masque != 255 ) { $tem_blanc = false ; }
}
 
if ($tem_blanc == true and $tem_noir == true ) { $tem_noir = false ; }
if ($tem_blanc == false and $tem_noir == false ) { $tem_noir = true ; $decoupe[] = $x ; }
 
$x++ ; //passage à la colonne suivante
}
 
 
 
 
 
 
 
// maintenant que j'ai l'abscisse de chaque début de lettre de mon masque, je vais m'occuper de trouver les luminosités par zones correspondants où va se faire le tag de chaque lettre
$nombre_lettres = count($decoupe) ;
 
if ( $sens == 'horizontal' )
{
//maintenant il faut faire une première passe sur les zones à tagger pour faire le calcul de la moyenne de couleur
 
$x_debut = $largeur_source - $largeur_masque - $marge_tag_x ;
$y_debut = $hauteur_source - $hauteur_masque - $marge_tag_y ;
$y_fin = $hauteur_source - $marge_tag_y - 1 ;
 
 
 
$effet = array() ; //on stockera dans ce tableau, l'effet qu'il faut appliquer sur la lettre;
for ( $lettre = 0 ; $lettre < $nombre_lettres ; $lettre++ )
{
$x_deb = $x_debut + $decoupe[$lettre] ; //abscisse de la gauche de la zone à scanner
if ( $lettre != $nombre_lettres - 1 ) { $x_fin = $x_debut + $decoupe[$lettre+1] -1 ; } else { $x_fin = $x_debut + $largeur_masque - 1 ; }
 
echo '$x_deb = '.$x_deb.' et $x_fin = '.$x_fin.'<br />' ;
 
$luminosite = 0 ;
$nb_pixels = 0 ;
for ( $x = $x_deb ; $x <= $x_fin ; $x++ )
{
for ( $y = $y_debut ; $y <= $y_fin ; $y++ )
{
$rgb = imagecolorat ( $img_source , $x , $y ) ;
$r = ($rgb >> 16) & 0xFF;
$g = ($rgb >> 8) & 0xFF;
$b = $rgb & 0xFF;
 
$luminosite = $luminosite + $r + $g + $b ;
$nb_pixels++ ;
}
}
$luminosite = floor($luminosite / 3 / $nb_pixels) ;
echo '$luminosite ( lettre n°'.($lettre+1).' ) = '.$luminosite.'<br /><br />' ;
 
$effet[] = $luminosite ;
}
 
 
 
// maintenant faut refaire une passe pour réaliser le marquage des lettres avec l'effet voulu
 
for ( $x = 0; $x < $largeur_masque ; $x++ )
{
// on doit récupérer l'effet qu'il faut appliquer.
// à chaque changement de lettre, je vais voir quel est l'effet qu'il faut prendre
foreach ( $decoupe as $key => $x_debut_lettre )
{
if ( $x == $x_debut_lettre )
{
if ( $effet[$key] >= $limite_luminosite ) { $effet_lettre = 'obscur' ; } else { $effet_lettre = 'clair' ; }
$opacite_corrigee = $opacite*correctif( $effet[$key] ) ;
//echo '$opacite_corrigee = '.$opacite_corrigee.'<br />' ;
break ;
}
}
 
for ( $y = 0; $y < $hauteur_masque ; $y++ )
{
//echo '( '.$x.', '.$y.' )<br />' ;
//ceci donne la couleur du pixel dans mon masque. Mais cela ne marche que si j'ai créé mon image avec createTrueColor
$rgb = imagecolorat ( $masque , $x , $y ) ;
$r_masque = ($rgb >> 16) & 0xFF;
$g_masque = ($rgb >> 8) & 0xFF;
$b_masque = $rgb & 0xFF;
 
 
 
//si la couleur du pixel de mon masque est blanche, je ne fais rien, sinon, je modifie la couleur de l'image à modifier
if ( !( $r_masque == 255 and $g_masque == 255 and $b_masque == 255 ) )
{
 
 
//ceci donne la couleur du pixel de mon image à modifier. Mais cela ne marche que si j'ai créé mon image avec createTrueColor
$rgb = imagecolorat ( $img_source , $x_debut + $x , $y_debut + $y ) ;
$r = ($rgb >> 16) & 0xFF;
$g = ($rgb >> 8) & 0xFF;
$b = $rgb & 0xFF;
 
 
 
if ( $r_masque == 1 and $g_masque == 1 and $b_masque == 1 )
{
if ( $effet_lettre == 'clair' )
{
$r = $r + (255-$r)*$opacite_corrigee/100 ;
$g = $g + (255-$g)*$opacite_corrigee/100 ;
$b = $b + (255-$b)*$opacite_corrigee/100;
 
if ( $r >= 255 ) { $r = 255 ; }
if ( $g >= 255 ) { $g = 255 ; }
if ( $b >= 255 ) { $b = 255 ; }
}
else
{
$r = $r - $r*$opacite/100/$coeff_opacite ;
$g = $g - $g*$opacite/100/$coeff_opacite ;
$b = $b - $b*$opacite/100/$coeff_opacite ;
 
if ( $r < 0 ) { $r = 0 ; }
if ( $g < 0 ) { $g = 0 ; }
if ( $b < 0 ) { $b = 0 ; }
}
 
//$r = 255 ; $g = 255 ; $b = 255 ;
$couleur = imagecolorallocate($img_source, $r, $g, $b) ;
imagesetpixel($img_source, $x_debut + $x, $y_debut + $y, $couleur) ;
imagecolordeallocate($img_source, $couleur) ;
}
 
else
{
$nuance_antialiasing_max = 2 ;
 
$nuance_antialiasing = ($nuance_antialiasing_max/255) * $r_masque + 1 ;
 
//avant, j'avais:
//$nuance_antialiasing = $r_masque/70 ;
//if ( $nuance_antialiasing < 1 ) { $nuance_antialiasing = 1 ; }
 
if ( $effet_lettre == 'clair' )
{
$r = $r + (255-$r)*$opacite_corrigee/100/$nuance_antialiasing ;
$g = $g + (255-$g)*$opacite_corrigee/100/$nuance_antialiasing ;
$b = $b + (255-$b)*$opacite_corrigee/100/$nuance_antialiasing ;
 
if ( $r >= 255 ) { $r = 255 ; }
if ( $g >= 255 ) { $g = 255 ; }
if ( $b >= 255 ) { $b = 255 ; }
}
else
{
$r = $r - $r*$opacite/100/$coeff_opacite/$nuance_antialiasing ;
$g = $g - $g*$opacite/100/$coeff_opacite/$nuance_antialiasing ;
$b = $b - $b*$opacite/100/$coeff_opacite/$nuance_antialiasing ;
 
if ( $r < 0 ) { $r = 0 ; }
if ( $g < 0 ) { $g = 0 ; }
if ( $b < 0 ) { $b = 0 ; }
}
 
 
$couleur = imagecolorallocate($img_source, $r, $g, $b) ;
imagesetpixel($img_source, $x_debut + $x, $y_debut + $y, $couleur) ;
imagecolordeallocate($img_source, $couleur) ;
}
 
}
 
 
}
}
}
 
else ////////////////////////////////////////////////// VERTICAL /////////////////////////////////////////////////
 
{
//maintenant il faut faire une première passe sur les zones à tagger pour faire le calcul de la moyenne de couleur
 
$y_debut = $hauteur_source - $marge_tag_y - 1 ;
$x_debut = $largeur_source - $hauteur_masque - $marge_tag_x ;
$x_fin = $largeur_source - $marge_tag_x - 1 ;
 
 
 
 
$effet = array() ; //on stockera dans ce tableau, l'effet qu'il faut appliquer sur la lettre;
for ( $lettre = 0 ; $lettre < $nombre_lettres ; $lettre++ )
{
$y_deb = $y_debut - $decoupe[$lettre] ; //ordonnée du bas de la zone à scanner
if ( $lettre != $nombre_lettres - 1 ) { $y_fin = $y_debut - $decoupe[$lettre+1] + 1 ; } else { $y_fin = $y_debut - $largeur_masque + 1 ; }
 
echo '$y_deb = '.$y_deb.' et $y_fin = '.$y_fin.'<br />' ;
 
$luminosite = 0 ; //on va caculer la luminosité de la zone
$nb_pixels = 0 ;
for ( $y = $y_deb ; $y >= $y_fin ; $y = $y-1 )
{
for ( $x = $x_debut ; $x <= $x_fin ; $x++ )
{
$rgb = imagecolorat ( $img_source , $x , $y ) ;
$r = ($rgb >> 16) & 0xFF;
$g = ($rgb >> 8) & 0xFF;
$b = $rgb & 0xFF;
 
$luminosite = $luminosite + $r + $g + $b ;
$nb_pixels++ ;
}
}
$luminosite = floor($luminosite / 3 / $nb_pixels) ;
echo '$luminosite ( lettre n°'.($lettre+1).' ) = '.$luminosite.'<br /><br />' ;
 
$effet[] = $luminosite ;
}
 
 
 
 
 
 
// maintenant faut refaire une passe pour réaliser le marquage des lettres avec l'effet voulu
 
//on parcours le masque de gauche à droite ( et de haut en bas )
for ( $x = 0; $x < $largeur_masque ; $x++ )
{
// on doit récupérer l'effet qu'il faut appliquer.
// à chaque changement de lettre, je vais voir quel est l'effet qu'il faut prendre
foreach ( $decoupe as $key => $x_debut_lettre )
{
if ( $x == $x_debut_lettre )
{
if ( $effet[$key] >= $limite_luminosite ) { $effet_lettre = 'obscur' ; } else { $effet_lettre = 'clair' ; }
$opacite_corrigee = $opacite*correctif( $effet[$key] ) ;
echo '$opacite_corrigee = '.$opacite_corrigee.'<br />' ;
break ;
}
}
 
for ( $y = 0; $y < $hauteur_masque ; $y++ )
{
//echo '( '.$x.', '.$y.' )<br />' ;
//ceci donne la couleur du pixel dans mon masque. Mais cela ne marche que si j'ai créé mon image avec createTrueColor
$rgb = imagecolorat ( $masque , $x , $y ) ;
$r_masque = ($rgb >> 16) & 0xFF;
$g_masque = ($rgb >> 8) & 0xFF;
$b_masque = $rgb & 0xFF;
 
 
 
//si la couleur du pixel de mon masque est blanche, je ne fais rien, sinon, je modifie la couleur de l'image à modifier
if ( !( $r_masque == 255 and $g_masque == 255 and $b_masque == 255 ) )
{
 
 
//ceci donne la couleur du pixel de mon image à modifier. Mais cela ne marche que si j'ai créé mon image avec createTrueColor
$rgb = imagecolorat ( $img_source , $x_debut + $y , $y_debut - $x ) ;
$r = ($rgb >> 16) & 0xFF;
$g = ($rgb >> 8) & 0xFF;
$b = $rgb & 0xFF;
 
 
 
if ( $r_masque == 1 and $g_masque == 1 and $b_masque == 1 )
{
if ( $effet_lettre == 'clair' )
{
$r = $r + (255-$r)*$opacite_corrigee/100 ;
$g = $g + (255-$g)*$opacite_corrigee/100 ;
$b = $b + (255-$b)*$opacite_corrigee/100;
 
if ( $r >= 255 ) { $r = 255 ; }
if ( $g >= 255 ) { $g = 255 ; }
if ( $b >= 255 ) { $b = 255 ; }
}
else
{
$r = $r - $r*$opacite/100/$coeff_opacite ;
$g = $g - $g*$opacite/100/$coeff_opacite ;
$b = $b - $b*$opacite/100/$coeff_opacite ;
 
if ( $r < 0 ) { $r = 0 ; }
if ( $g < 0 ) { $g = 0 ; }
if ( $b < 0 ) { $b = 0 ; }
}
 
//$r = 255 ; $g = 255 ; $b = 255 ;
$couleur = imagecolorallocate($img_source, $r, $g, $b) ;
imagesetpixel($img_source, $x_debut + $y , $y_debut - $x, $couleur) ;
imagecolordeallocate($img_source, $couleur) ;
}
 
else
{
$nuance_antialiasing_max = 2 ;
 
$nuance_antialiasing = ($nuance_antialiasing_max/255) * $r_masque + 1 ;
 
if ( $effet_lettre == 'clair' )
{
$r = $r + (255-$r)*$opacite_corrigee/100/$nuance_antialiasing ;
$g = $g + (255-$g)*$opacite_corrigee/100/$nuance_antialiasing ;
$b = $b + (255-$b)*$opacite_corrigee/100/$nuance_antialiasing ;
 
if ( $r >= 255 ) { $r = 255 ; }
if ( $g >= 255 ) { $g = 255 ; }
if ( $b >= 255 ) { $b = 255 ; }
}
else
{
$r = $r - $r*$opacite/100/$coeff_opacite/$nuance_antialiasing ;
$g = $g - $g*$opacite/100/$coeff_opacite/$nuance_antialiasing ;
$b = $b - $b*$opacite/100/$coeff_opacite/$nuance_antialiasing ;
 
if ( $r < 0 ) { $r = 0 ; }
if ( $g < 0 ) { $g = 0 ; }
if ( $b < 0 ) { $b = 0 ; }
}
 
 
$couleur = imagecolorallocate($img_source, $r, $g, $b) ;
imagesetpixel($img_source, $x_debut + $y , $y_debut - $x, $couleur) ;
imagecolordeallocate($img_source, $couleur) ;
}
 
}
 
 
}
}
 
}
 
 
 
////////// enregistrer sur le disque dur l'image taggée
$fichier_sortie = $dossier.'/'.$nom_image.'-abaca.jpg' ; ;
imagejpeg( $img_source, $fichier_sortie, 85); //100 permet d'avoir une image de qualité maximum (pour le jpeg)
 
echo '<table style="float:left; margin-right:50px;"><tbody><tr><td>
<div><img src="'
.$fichier_sortie.'" style="width:'.$largeur_source.'px" /></div>
<div>'
.$fichier_sortie.'</div>
</td></tr></tbody></table>'
;
}
 
 
 
 
 
echo 'fini à '.date('H:i:s').'<br /><br />';
 


Wladimir Yordanoff

Denis Lavant

Bernard Giraudeau

Anne Alvaro

Robert Carlyle

Sam Karmann

Pierre Palmade

Roger Moore

Géraldine Nakache

Tony Curtis

Sacha Baron Cohen

Pascal Légitimus

Josh Hutcherson

Pierre Niney

Michel Delpech

Jean-Paul Rouve

Marisa Tomei

Pierce Brosnan