Ignore:
Timestamp:
Dec 13, 2015, 11:35:58 AM (5 years ago)
Author:
cedric@…
Message:

Indentation et regles de codage selon http://www.spip.net/fr_article3497.html#regles_codage

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _core_/plugins/filtres_images/filtres/images_transforme.php

    r93466 r93611  
    1919 */
    2020
    21 if (!defined('_ECRIRE_INC_VERSION')) return;
     21if (!defined('_ECRIRE_INC_VERSION')) {
     22        return;
     23}
    2224
    2325// librairie de base du core
     
    3436// 3/ $transparence a "true" permet de conserver la transparence (utile pour conversion GIF)
    3537// http://code.spip.net/@image_aplatir
    36 function image_aplatir($im, $format = 'jpg', $coul = '000000', $qualite = NULL, $transparence = false)
    37 {
    38         if ($qualite===NULL){
    39                 if ($format=='jpg') $qualite=_IMG_GD_QUALITE;
    40                 elseif ($format=='png') $qualite=0;
    41                 else $qualite=128;
     38function image_aplatir($im, $format = 'jpg', $coul = '000000', $qualite = null, $transparence = false) {
     39        if ($qualite === null) {
     40                if ($format == 'jpg') {
     41                        $qualite = _IMG_GD_QUALITE;
     42                } elseif ($format == 'png') {
     43                        $qualite = 0;
     44                } else {
     45                        $qualite = 128;
     46                }
    4247        }
    4348        $fonction = array('image_aplatir', func_get_args());
    4449        $image = _image_valeurs_trans($im, "aplatir-$format-$coul-$qualite-$transparence", $format, $fonction);
    4550
    46         if (!$image) return("");
     51        if (!$image) {
     52                return ("");
     53        }
    4754
    4855        include_spip('inc/filtres');
    4956        $couleurs = _couleur_hex_to_dec($coul);
    50         $dr= $couleurs["red"];
    51         $dv= $couleurs["green"];
    52         $db= $couleurs["blue"];
     57        $dr = $couleurs["red"];
     58        $dv = $couleurs["green"];
     59        $db = $couleurs["blue"];
    5360
    5461        $x_i = $image["largeur"];
    5562        $y_i = $image["hauteur"];
    56        
     63
    5764        $im = $image["fichier"];
    5865        $dest = $image["fichier_dest"];
    59        
     66
    6067        $creer = $image["creer"];
    6168
     
    6471                imagepalettetotruecolor($im);
    6572                $im_ = imagecreatetruecolor($x_i, $y_i);
    66                 if ($image["format_source"] == "gif" AND function_exists('ImageCopyResampled')) { 
     73                if ($image["format_source"] == "gif" AND function_exists('ImageCopyResampled')) {
    6774                        // Si un GIF est transparent,
    6875                        // fabriquer un PNG transparent 
    6976                        // Conserver la transparence
    70                         @imagealphablending($im_, false);
    71                         @imagesavealpha($im_,true);
    72                         if (function_exists("imageAntiAlias")) imageAntiAlias($im_,true);
     77                        @imagealphablending($im_, false);
     78                        @imagesavealpha($im_, true);
     79                        if (function_exists("imageAntiAlias")) {
     80                                imageAntiAlias($im_, true);
     81                        }
    7382                        @ImageCopyResampled($im_, $im, 0, 0, 0, 0, $x_i, $y_i, $x_i, $y_i);
    7483                        imagedestroy($im);
    7584                        $im = $im_;
    7685                }
    77                
     86
    7887                // allouer la couleur de fond
    7988                if ($transparence) {
    80                         @imagealphablending($im_, false);
    81                         @imagesavealpha($im_,true);
    82                         $color_t = imagecolorallocatealpha( $im_, $dr, $dv, $db, 127);
    83                 }
    84                 else $color_t = ImageColorAllocate( $im_, $dr, $dv, $db);
    85                
    86                 imagefill ($im_, 0, 0, $color_t);
     89                        @imagealphablending($im_, false);
     90                        @imagesavealpha($im_, true);
     91                        $color_t = imagecolorallocatealpha($im_, $dr, $dv, $db, 127);
     92                } else {
     93                        $color_t = ImageColorAllocate($im_, $dr, $dv, $db);
     94                }
     95
     96                imagefill($im_, 0, 0, $color_t);
    8797
    8898                //??
    8999                //$dist = abs($trait);
    90                
     100
    91101                $transp_x = false;
    92                
     102
    93103                if ($image["format_source"] == "jpg") {
    94104                        $im_ = &$im;
    95                 }
    96                 else {
     105                } else {
    97106                        for ($x = 0; $x < $x_i; $x++) {
    98                                 for ($y=0; $y < $y_i; $y++) {
     107                                for ($y = 0; $y < $y_i; $y++) {
    99108
    100109                                        $rgb = ImageColorAt($im, $x, $y);
     
    104113                                        $b = $rgb & 0xFF;
    105114
    106                                         $a = (127-$a) / 127;
     115                                        $a = (127-$a)/127;
    107116
    108117                                        if ($a == 1) { // Limiter calculs
     
    110119                                                $g = $g;
    111120                                                $b = $b;
     121                                        } else {
     122                                                if ($a == 0) { // Limiter calculs
     123                                                        $r = $dr;
     124                                                        $g = $dv;
     125                                                        $b = $db;
     126
     127                                                        $transp_x = $x; // Memoriser un point transparent
     128                                                        $transp_y = $y;
     129
     130                                                } else {
     131                                                        $r = round($a*$r+$dr*(1-$a));
     132                                                        $g = round($a*$g+$dv*(1-$a));
     133                                                        $b = round($a*$b+$db*(1-$a));
     134                                                }
    112135                                        }
    113                                         else if ($a == 0) { // Limiter calculs
    114                                                 $r = $dr;
    115                                                 $g = $dv;
    116                                                 $b = $db;
    117 
    118                                                 $transp_x = $x; // Memoriser un point transparent
    119                                                 $transp_y = $y;
    120 
    121                                         } else {
    122                                                 $r = round($a * $r + $dr * (1-$a));
    123                                                 $g = round($a * $g + $dv * (1-$a));
    124                                                 $b = round($a * $b + $db * (1-$a));
    125                                         }
    126                                         $a = (1-$a) *127;
    127                                         $color = ImageColorAllocateAlpha( $im_, $r, $g, $b, $a);
    128                                         imagesetpixel ($im_, $x, $y, $color);
     136                                        $a = (1-$a)*127;
     137                                        $color = ImageColorAllocateAlpha($im_, $r, $g, $b, $a);
     138                                        imagesetpixel($im_, $x, $y, $color);
    129139                                }
    130140                        }
    131141                }
    132142                // passer en palette si besoin
    133                 if ($format=='gif' OR ($format=='png' AND $qualite!==0)){
     143                if ($format == 'gif' OR ($format == 'png' AND $qualite !== 0)) {
    134144                        // creer l'image finale a palette
    135145                        // (on recycle l'image initiale si possible, sinon on en recree une)
    136                         if ($im===$im_)
     146                        if ($im === $im_) {
    137147                                $im = imagecreatetruecolor($x_i, $y_i);
    138 
    139                         @imagetruecolortopalette($im,true,$qualite);
     148                        }
     149
     150                        @imagetruecolortopalette($im, true, $qualite);
    140151
    141152
     
    145156                        // matcher les couleurs au mieux par rapport a l'image initiale
    146157                        // si la fonction est disponible (php>=4.3)
    147                         if (function_exists('imagecolormatch'))
     158                        if (function_exists('imagecolormatch')) {
    148159                                @imagecolormatch($im_, $im);
    149                                
    150                         if ($format=='gif' && $transparence && $transp_x) {     
    151                                 $color_t = ImagecolorAt( $im, $transp_x, $transp_y);
    152                                 if ($format == "gif" && $transparence) @imagecolortransparent($im, $color_t);
    153                         }
    154                                
    155                                
     160                        }
     161
     162                        if ($format == 'gif' && $transparence && $transp_x) {
     163                                $color_t = ImagecolorAt($im, $transp_x, $transp_y);
     164                                if ($format == "gif" && $transparence) {
     165                                        @imagecolortransparent($im, $color_t);
     166                                }
     167                        }
     168
     169
    156170                        // produire le resultat
    157171                        _image_gd_output($im, $image, $qualite);
    158                 }
    159                 else
     172                } else {
    160173                        _image_gd_output($im_, $image, $qualite);
    161                 if ($im!==$im_)
     174                }
     175                if ($im !== $im_) {
    162176                        imagedestroy($im);
     177                }
    163178                imagedestroy($im_);
    164179        }
    165         return _image_ecrire_tag($image,array('src'=>$dest));
     180
     181        return _image_ecrire_tag($image, array('src' => $dest));
    166182}
    167183
     
    173189function image_format($img, $format = 'png') {
    174190        $qualite = null;
    175         if ($format=='png8') {$format='png';$qualite=128;}
     191        if ($format == 'png8') {
     192                $format = 'png';
     193                $qualite = 128;
     194        }
     195
    176196        return image_aplatir($img, $format, 'cccccc', $qualite, true);
    177197}
     
    182202// alpha = 127: completement transparent
    183203// http://code.spip.net/@image_alpha
    184 function image_alpha($im, $alpha = 63)
    185 {
     204function image_alpha($im, $alpha = 63) {
    186205        $fonction = array('image_alpha', func_get_args());
    187         $image = _image_valeurs_trans($im, "alpha-$alpha", "png",$fonction);
    188         if (!$image) return("");
    189        
     206        $image = _image_valeurs_trans($im, "alpha-$alpha", "png", $fonction);
     207        if (!$image) {
     208                return ("");
     209        }
     210
    190211        $x_i = $image["largeur"];
    191212        $y_i = $image["hauteur"];
    192        
     213
    193214        $im = $image["fichier"];
    194215        $dest = $image["fichier_dest"];
    195        
     216
    196217        $creer = $image["creer"];
    197        
     218
    198219        if ($creer) {
    199220                // Creation de l'image en deux temps
     
    203224                $im2 = imagecreatetruecolor($x_i, $y_i);
    204225                @imagealphablending($im2, false);
    205                 @imagesavealpha($im2,true);
    206                 $color_t = ImageColorAllocateAlpha( $im2, 255, 255, 255 , 127 );
    207                 imagefill ($im2, 0, 0, $color_t);
     226                @imagesavealpha($im2, true);
     227                $color_t = ImageColorAllocateAlpha($im2, 255, 255, 255, 127);
     228                imagefill($im2, 0, 0, $color_t);
    208229                imagecopy($im2, $im, 0, 0, 0, 0, $x_i, $y_i);
    209230
    210231                $im_ = imagecreatetruecolor($x_i, $y_i);
    211                 imagealphablending ($im_, FALSE );
    212                 imagesavealpha ( $im_, TRUE );
    213 
     232                imagealphablending($im_, false);
     233                imagesavealpha($im_, true);
    214234
    215235
     
    217237                        for ($y = 0; $y < $y_i; $y++) {
    218238                                $rgb = ImageColorAt($im2, $x, $y);
    219                                
     239
    220240                                if (function_exists('imagecolorallocatealpha')) {
    221241                                        $a = ($rgb >> 24) & 0xFF;
     
    223243                                        $g = ($rgb >> 8) & 0xFF;
    224244                                        $b = $rgb & 0xFF;
    225                                        
    226                                        
    227                                         $a_ = $alpha + $a - round($a*$alpha/127);
     245
     246
     247                                        $a_ = $alpha+$a-round($a*$alpha/127);
    228248                                        $rgb = imagecolorallocatealpha($im_, $r, $g, $b, $a_);
    229249                                }
    230                                 imagesetpixel ( $im_, $x, $y, $rgb );
    231                         }
    232                 }
    233                 _image_gd_output($im_,$image);
     250                                imagesetpixel($im_, $x, $y, $rgb);
     251                        }
     252                }
     253                _image_gd_output($im_, $image);
    234254                imagedestroy($im_);
    235255                imagedestroy($im);
     
    237257        }
    238258
    239         return _image_ecrire_tag($image,array('src'=>$dest));
     259        return _image_ecrire_tag($image, array('src' => $dest));
    240260}
    241261
     
    252272 *     - `[(#FICHIER|image_recadre{16:9})]`
    253273 *     - `[(#FICHIER|image_recadre{16:9, -})]` (- est appliqué par défaut, équivalent à image_passe_partout)
    254  *     - `[(#FICHIER|image_recadre{16:9, +, center, white})]` 
     274 *     - `[(#FICHIER|image_recadre{16:9, +, center, white})]`
    255275 *     - `[(#FICHIER|image_recadre{16:9, -, top left})]`
    256276 *     - `[(#FICHIER|image_recadre{16:9, -, top=40 left=20})]`
     
    261281 * @uses _image_ecrire_tag()
    262282 * @link http://www.spip.net/5786
    263  * 
     283 *
    264284 * @param string $im
    265285 *     Chemin de l'image ou balise html `<img src=... />`
     
    281301 *     balise image recadrée
    282302 */
    283 function image_recadre($im, $width, $height, $position = 'center', $background_color = 'white')
    284 {
     303function image_recadre($im, $width, $height, $position = 'center', $background_color = 'white') {
    285304        $fonction = array('image_recadre', func_get_args());
    286         $image = _image_valeurs_trans($im, "recadre-$width-$height-$position-$background_color",false,$fonction);
    287 
    288         if (!$image) return("");
    289        
     305        $image = _image_valeurs_trans($im, "recadre-$width-$height-$position-$background_color", false, $fonction);
     306
     307        if (!$image) {
     308                return ("");
     309        }
     310
    290311        $x_i = $image["largeur"];
    291312        $y_i = $image["hauteur"];
    292313
    293         if (_IMG_GD_MAX_PIXELS && $x_i*$y_i>_IMG_GD_MAX_PIXELS){
    294                 spip_log("image_recadre impossible sur $im : ".$srcWidth*$srcHeight."pixels");
     314        if (_IMG_GD_MAX_PIXELS && $x_i*$y_i > _IMG_GD_MAX_PIXELS) {
     315                spip_log("image_recadre impossible sur $im : " . $srcWidth*$srcHeight . "pixels");
     316
    295317                // on se rabat sur une reduction CSS
    296                 return _image_tag_changer_taille($im,$width,$height);
     318                return _image_tag_changer_taille($im, $width, $height);
    297319        }
    298320
     
    300322        // width : "16:9"
    301323        // height : "+" pour agrandir l'image et "-" pour la croper
    302         if (strpos($width,":")!==false){
    303                 list($wr,$hr) = explode(":",$width);
    304                 $hm = $x_i / $wr * $hr;
    305                 $ym = $y_i / $hr * $wr;
    306                 if ($height=="+"?($y_i<$hm):($y_i>$hm)){
     324        if (strpos($width, ":") !== false) {
     325                list($wr, $hr) = explode(":", $width);
     326                $hm = $x_i/$wr*$hr;
     327                $ym = $y_i/$hr*$wr;
     328                if ($height == "+" ? ($y_i < $hm) : ($y_i > $hm)) {
    307329                        $width = $x_i;
    308330                        $height = $hm;
    309                 }
    310                 else {
     331                } else {
    311332                        $width = $ym;
    312333                        $height = $y_i;
     
    314335        }
    315336
    316         if ($width==0) $width=$x_i;
    317         if ($height==0) $height=$y_i;
     337        if ($width == 0) {
     338                $width = $x_i;
     339        }
     340        if ($height == 0) {
     341                $height = $y_i;
     342        }
    318343
    319344        $offset_width = $x_i-$width;
    320345        $offset_height = $y_i-$height;
    321         $position=strtolower($position);
     346        $position = strtolower($position);
    322347
    323348        // chercher une fonction spéciale de calcul des coordonnées de positionnement.
     
    332357        }
    333358
    334         if (strpos($position,'left')!==FALSE) {
    335                 if (preg_match(';left=(\d{1}\d+);', $position, $left)){
    336                         $offset_width=$left[1];
     359        if (strpos($position, 'left') !== false) {
     360                if (preg_match(';left=(\d{1}\d+);', $position, $left)) {
     361                        $offset_width = $left[1];
    337362                } else {
    338                         $offset_width=0;
    339                 }
    340         } elseif (strpos($position,'right')!==FALSE) {
    341                 $offset_width=$offset_width;
     363                        $offset_width = 0;
     364                }
     365        } elseif (strpos($position, 'right') !== false) {
     366                $offset_width = $offset_width;
    342367        } else {
    343                 $offset_width=intval(ceil($offset_width/2));
    344         }
    345 
    346         if (strpos($position,'top')!==FALSE) {
    347                 if (preg_match(';top=(\d{1}\d+);', $position, $top)){
    348                         $offset_height=$top[1];
     368                $offset_width = intval(ceil($offset_width/2));
     369        }
     370
     371        if (strpos($position, 'top') !== false) {
     372                if (preg_match(';top=(\d{1}\d+);', $position, $top)) {
     373                        $offset_height = $top[1];
    349374                } else {
    350                         $offset_height=0;
    351                 }
    352         } elseif (strpos($position,'bottom')!==FALSE) {
    353                 $offset_height=$offset_height;
     375                        $offset_height = 0;
     376                }
     377        } elseif (strpos($position, 'bottom') !== false) {
     378                $offset_height = $offset_height;
    354379        } else {
    355                 $offset_height=intval(ceil($offset_height/2));
     380                $offset_height = intval(ceil($offset_height/2));
    356381        }
    357382
     
    366391                $im_ = imagecreatetruecolor($width, $height);
    367392                @imagealphablending($im_, false);
    368                 @imagesavealpha($im_,true);
    369 
    370                 if ($background_color=='transparent') {
    371                         $color_t = imagecolorallocatealpha( $im_, 255, 255, 255 , 127 );
     393                @imagesavealpha($im_, true);
     394
     395                if ($background_color == 'transparent') {
     396                        $color_t = imagecolorallocatealpha($im_, 255, 255, 255, 127);
    372397                } else {
    373398                        $bg = _couleur_hex_to_dec($background_color);
    374                         $color_t = imagecolorallocate( $im_, $bg['red'], $bg['green'], $bg['blue']);
    375                 }
    376                 imagefill ($im_, 0, 0, $color_t);
    377                 imagecopy($im_, $im, max(0,-$offset_width), max(0,-$offset_height), max(0,$offset_width), max(0,$offset_height), min($width,$x_i), min($height,$y_i));
    378 
    379                 _image_gd_output($im_,$image);
     399                        $color_t = imagecolorallocate($im_, $bg['red'], $bg['green'], $bg['blue']);
     400                }
     401                imagefill($im_, 0, 0, $color_t);
     402                imagecopy($im_, $im, max(0, -$offset_width), max(0, -$offset_height), max(0, $offset_width), max(0, $offset_height),
     403                        min($width, $x_i), min($height, $y_i));
     404
     405                _image_gd_output($im_, $image);
    380406                imagedestroy($im_);
    381407                imagedestroy($im);
    382408        }
    383409
    384         return _image_ecrire_tag($image, array('src'=>$dest, 'width'=>$width, 'height'=>$height));
     410        return _image_ecrire_tag($image, array('src' => $dest, 'width' => $width, 'height' => $height));
    385411}
    386412
     
    393419 * @return string
    394420 */
    395 function image_recadre_mini($im)
    396 {
     421function image_recadre_mini($im) {
    397422        $fonction = array('image_recadre_mini', func_get_args());
    398         $image = _image_valeurs_trans($im, "recadre_mini",false,$fonction);
    399 
    400         if (!$image) return("");
     423        $image = _image_valeurs_trans($im, "recadre_mini", false, $fonction);
     424
     425        if (!$image) {
     426                return ("");
     427        }
    401428
    402429        $width = $image["largeur"];
     
    417444                $max_y = $max_x = 0;
    418445                $yy = 0;
    419                 while ($yy<=$height/2 AND $max_y<=$min_y){
    420                         if($yy<$min_y)
     446                while ($yy <= $height/2 AND $max_y <= $min_y) {
     447                        if ($yy < $min_y) {
    421448                                for ($xx = 0; $xx < $width; $xx++) {
    422449                                        $color_index = imagecolorat($im, $xx, $yy);
    423450                                        $color_tran = imagecolorsforindex($im, $color_index);
    424                                         if ($color_tran['alpha']!==127){
    425                                                 $min_y = min($yy,$min_y);
    426                                                 $max_y = max($height-1-$yy,$max_y);
     451                                        if ($color_tran['alpha'] !== 127) {
     452                                                $min_y = min($yy, $min_y);
     453                                                $max_y = max($height-1-$yy, $max_y);
    427454                                                break;
    428455                                        }
    429456                                }
    430                         if($height-1-$yy>$max_y)
     457                        }
     458                        if ($height-1-$yy > $max_y) {
    431459                                for ($xx = 0; $xx < $width; $xx++) {
    432460                                        $color_index = imagecolorat($im, $xx, $height-1-$yy);
    433461                                        $color_tran = imagecolorsforindex($im, $color_index);
    434                                         if ($color_tran['alpha']!==127){
    435                                                 $min_y = min($yy,$min_y);
    436                                                 $max_y = max($height-1-$yy,$max_y);
     462                                        if ($color_tran['alpha'] !== 127) {
     463                                                $min_y = min($yy, $min_y);
     464                                                $max_y = max($height-1-$yy, $max_y);
    437465                                                break;
    438466                                        }
    439467                                }
     468                        }
    440469                        $yy++;
    441470                }
    442                 $min_y = min($max_y,$min_y); // tout a 0 aucun pixel trouve
     471                $min_y = min($max_y, $min_y); // tout a 0 aucun pixel trouve
    443472
    444473                $xx = 0;
    445                 while ($xx<=$width/2 AND $max_x<=$min_x){
    446                         if ($xx<$min_x)
     474                while ($xx <= $width/2 AND $max_x <= $min_x) {
     475                        if ($xx < $min_x) {
    447476                                for ($yy = $min_y; $yy < $max_y; $yy++) {
    448477                                        $color_index = imagecolorat($im, $xx, $yy);
    449478                                        $color_tran = imagecolorsforindex($im, $color_index);
    450                                         if ($color_tran['alpha']!==127){
    451                                                 $min_x = min($xx,$min_x);
    452                                                 $max_x = max($xx,$max_x);
     479                                        if ($color_tran['alpha'] !== 127) {
     480                                                $min_x = min($xx, $min_x);
     481                                                $max_x = max($xx, $max_x);
    453482                                                break; // inutile de continuer sur cette colonne
    454483                                        }
    455484                                }
    456                         if ($width-1-$xx>$max_x)
     485                        }
     486                        if ($width-1-$xx > $max_x) {
    457487                                for ($yy = $min_y; $yy < $max_y; $yy++) {
    458488                                        $color_index = imagecolorat($im, $width-1-$xx, $yy);
    459489                                        $color_tran = imagecolorsforindex($im, $color_index);
    460                                         if ($color_tran['alpha']!==127){
    461                                                 $min_x = min($width-1-$xx,$min_x);
    462                                                 $max_x = max($width-1-$xx,$max_x);
     490                                        if ($color_tran['alpha'] !== 127) {
     491                                                $min_x = min($width-1-$xx, $min_x);
     492                                                $max_x = max($width-1-$xx, $max_x);
    463493                                                break; // inutile de continuer sur cette colonne
    464494                                        }
    465495                                }
     496                        }
    466497                        $xx++;
    467498                }
    468                 $min_x = min($max_x,$min_x); // tout a 0 aucun pixel trouve
     499                $min_x = min($max_x, $min_x); // tout a 0 aucun pixel trouve
    469500
    470501                $width = $max_x-$min_x+1;
     
    473504                $im_ = imagecreatetruecolor($width, $height);
    474505                @imagealphablending($im_, false);
    475                 @imagesavealpha($im_,true);
    476 
    477                 $color_t = imagecolorallocatealpha( $im_, 255, 255, 255 , 127 );
    478                 imagefill ($im_, 0, 0, $color_t);
     506                @imagesavealpha($im_, true);
     507
     508                $color_t = imagecolorallocatealpha($im_, 255, 255, 255, 127);
     509                imagefill($im_, 0, 0, $color_t);
    479510                imagecopy($im_, $im, 0, 0, $min_x, $min_y, $width, $height);
    480511
    481                 _image_gd_output($im_,$image);
     512                _image_gd_output($im_, $image);
    482513                imagedestroy($im_);
    483514                imagedestroy($im);
    484         }
    485         else {
    486                 list ($height,$width) = taille_image($image['fichier_dest']);
    487         }
    488 
    489         return _image_ecrire_tag($image,array('src'=>$dest,'width'=>$width,'height'=>$height));
     515        } else {
     516                list ($height, $width) = taille_image($image['fichier_dest']);
     517        }
     518
     519        return _image_ecrire_tag($image, array('src' => $dest, 'width' => $width, 'height' => $height));
    490520}
    491521
    492522
    493523// http://code.spip.net/@image_flip_vertical
    494 function image_flip_vertical($im)
    495 {
     524function image_flip_vertical($im) {
    496525        $fonction = array('image_flip_vertical', func_get_args());
    497         $image = _image_valeurs_trans($im, "flip_v", false,$fonction);
    498         if (!$image) return("");
    499        
     526        $image = _image_valeurs_trans($im, "flip_v", false, $fonction);
     527        if (!$image) {
     528                return ("");
     529        }
     530
    500531        $x_i = $image["largeur"];
    501532        $y_i = $image["hauteur"];
    502        
     533
    503534        $im = $image["fichier"];
    504535        $dest = $image["fichier_dest"];
    505        
     536
    506537        $creer = $image["creer"];
    507        
     538
    508539        if ($creer) {
    509540                $im = $image["fonction_imagecreatefrom"]($im);
     
    511542                $im_ = imagecreatetruecolor($x_i, $y_i);
    512543                @imagealphablending($im_, false);
    513                 @imagesavealpha($im_,true);
    514        
    515                 $color_t = ImageColorAllocateAlpha( $im_, 255, 255, 255 , 127 );
    516                 imagefill ($im_, 0, 0, $color_t);
     544                @imagesavealpha($im_, true);
     545
     546                $color_t = ImageColorAllocateAlpha($im_, 255, 255, 255, 127);
     547                imagefill($im_, 0, 0, $color_t);
    517548
    518549                for ($x = 0; $x < $x_i; $x++) {
    519550                        for ($y = 0; $y < $y_i; $y++) {
    520                                 imagecopy($im_, $im, $x_i - $x - 1, $y, $x, $y, 1, 1);
    521                         }
    522                 }
    523 
    524                 _image_gd_output($im_,$image);
     551                                imagecopy($im_, $im, $x_i-$x-1, $y, $x, $y, 1, 1);
     552                        }
     553                }
     554
     555                _image_gd_output($im_, $image);
    525556                imagedestroy($im_);
    526557                imagedestroy($im);
    527558        }
    528        
    529         return _image_ecrire_tag($image,array('src'=>$dest));
     559
     560        return _image_ecrire_tag($image, array('src' => $dest));
    530561}
    531562
    532563// http://code.spip.net/@image_flip_horizontal
    533 function image_flip_horizontal($im)
    534 {
     564function image_flip_horizontal($im) {
    535565        $fonction = array('image_flip_horizontal', func_get_args());
    536         $image = _image_valeurs_trans($im, "flip_h",false,$fonction);
    537         if (!$image) return("");
    538        
     566        $image = _image_valeurs_trans($im, "flip_h", false, $fonction);
     567        if (!$image) {
     568                return ("");
     569        }
     570
    539571        $x_i = $image["largeur"];
    540572        $y_i = $image["hauteur"];
    541        
     573
    542574        $im = $image["fichier"];
    543575        $dest = $image["fichier_dest"];
    544        
     576
    545577        $creer = $image["creer"];
    546        
     578
    547579        if ($creer) {
    548580                $im = $image["fonction_imagecreatefrom"]($im);
     
    550582                $im_ = imagecreatetruecolor($x_i, $y_i);
    551583                @imagealphablending($im_, false);
    552                 @imagesavealpha($im_,true);
    553        
    554                 $color_t = ImageColorAllocateAlpha( $im_, 255, 255, 255 , 127 );
    555                 imagefill ($im_, 0, 0, $color_t);
     584                @imagesavealpha($im_, true);
     585
     586                $color_t = ImageColorAllocateAlpha($im_, 255, 255, 255, 127);
     587                imagefill($im_, 0, 0, $color_t);
    556588
    557589                for ($x = 0; $x < $x_i; $x++) {
    558590                        for ($y = 0; $y < $y_i; $y++) {
    559                                 imagecopy($im_, $im, $x, $y_i - $y - 1, $x, $y, 1, 1);
    560                         }
    561                 }
    562                 _image_gd_output($im_,$image);
     591                                imagecopy($im_, $im, $x, $y_i-$y-1, $x, $y, 1, 1);
     592                        }
     593                }
     594                _image_gd_output($im_, $image);
    563595                imagedestroy($im_);
    564596                imagedestroy($im);
    565597        }
    566        
    567         return _image_ecrire_tag($image,array('src'=>$dest));
     598
     599        return _image_ecrire_tag($image, array('src' => $dest));
    568600}
    569601
     
    610642        $texte = $arg_list[0];
    611643        for ($i = 1; $i < $numargs; $i++) {
    612                 if ( ($p = strpos($arg_list[$i],"=")) !==false) {
     644                if (($p = strpos($arg_list[$i], "=")) !== false) {
    613645                        $nom_variable = substr($arg_list[$i], 0, $p);
    614646                        $val_variable = substr($arg_list[$i], $p+1);
     
    624656        // - une balise <img src='...' />
    625657        // - une image avec un timestamp ?01234
    626         $mask = _image_valeurs_trans($masque, "source-image_masque", "png",null, true);
    627         if (!$mask) return("");
     658        $mask = _image_valeurs_trans($masque, "source-image_masque", "png", null, true);
     659        if (!$mask) {
     660                return ("");
     661        }
    628662        $masque = $mask['fichier'];
    629663
    630         $pos = md5(serialize($variable).$mask['date_src']);
     664        $pos = md5(serialize($variable) . $mask['date_src']);
    631665        $fonction = array('image_masque', func_get_args());
    632         $image = _image_valeurs_trans($im, "masque-$masque-$pos", "png",$fonction);
    633         if (!$image) return("");
     666        $image = _image_valeurs_trans($im, "masque-$masque-$pos", "png", $fonction);
     667        if (!$image) {
     668                return ("");
     669        }
    634670
    635671        $x_i = $image["largeur"];
     
    651687
    652688        if ($creer) {
    653                
     689
    654690                $im_m = $mask["fichier"];
    655691                $x_m = $mask["largeur"];
     
    657693
    658694                $im2 = $mask["fonction_imagecreatefrom"]($masque);
    659                 if ($mask["format_source"] == "gif" AND function_exists('ImageCopyResampled')) { 
     695                if ($mask["format_source"] == "gif" AND function_exists('ImageCopyResampled')) {
    660696                        $im2_ = imagecreatetruecolor($x_m, $y_m);
    661697                        // Si un GIF est transparent,
    662698                        // fabriquer un PNG transparent 
    663699                        // Conserver la transparence
    664                         if (function_exists("imageAntiAlias")) imageAntiAlias($im2_,true);
    665                         @imagealphablending($im2_, false);
    666                         @imagesavealpha($im2_,true);
     700                        if (function_exists("imageAntiAlias")) {
     701                                imageAntiAlias($im2_, true);
     702                        }
     703                        @imagealphablending($im2_, false);
     704                        @imagesavealpha($im2_, true);
    667705                        @ImageCopyResampled($im2_, $im2, 0, 0, 0, 0, $x_m, $y_m, $x_m, $y_m);
    668706                        imagedestroy($im2);
     
    678716                        $dx = 0;
    679717                        $dy = 0;
    680                        
     718
    681719                        if (isset($defini["right"]) and $defini["right"]) {
    682720                                $right = $variable["right"];
    683                                 $dx = ($x_i - $x_m) - $right;
     721                                $dx = ($x_i-$x_m)-$right;
    684722                        }
    685723                        if (isset($defini["bottom"]) and $defini["bottom"]) {
    686724                                $bottom = $variable["bottom"];
    687                                 $dy = ($y_i - $y_m) - $bottom;
    688                                 }
     725                                $dy = ($y_i-$y_m)-$bottom;
     726                        }
    689727                        if (isset($defini["top"]) and $defini["top"]) {
    690728                                $top = $variable["top"];
     
    699737                                if ($align == "right") {
    700738                                        $right = 0;
    701                                         $dx = ($x_i - $x_m);
    702                                 } else if ($align == "left") {
    703                                         $left = 0;
    704                                         $dx = 0;
    705                                 } else if ($align = "center") {
    706                                         $dx = round( ($x_i - $x_m) / 2 ) ;
     739                                        $dx = ($x_i-$x_m);
     740                                } else {
     741                                        if ($align == "left") {
     742                                                $left = 0;
     743                                                $dx = 0;
     744                                        } else {
     745                                                if ($align = "center") {
     746                                                        $dx = round(($x_i-$x_m)/2);
     747                                                }
     748                                        }
    707749                                }
    708750                        }
     
    711753                                if ($valign == "bottom") {
    712754                                        $bottom = 0;
    713                                         $dy = ($y_i - $y_m);
    714                                 } else if ($valign == "top") {
    715                                         $top = 0;
    716                                         $dy = 0;
    717                                 } else if ($valign = "middle") {
    718                                         $dy = round( ($y_i - $y_m) / 2 ) ;
     755                                        $dy = ($y_i-$y_m);
     756                                } else {
     757                                        if ($valign == "top") {
     758                                                $top = 0;
     759                                                $dy = 0;
     760                                        } else {
     761                                                if ($valign = "middle") {
     762                                                        $dy = round(($y_i-$y_m)/2);
     763                                                }
     764                                        }
    719765                                }
    720766                        }
     
    723769                        $im3 = imagecreatetruecolor($x_i, $y_i);
    724770                        @imagealphablending($im3, false);
    725                         @imagesavealpha($im3,true);
    726                         if ($mode == "masque") $color_t = ImageColorAllocateAlpha( $im3, 128, 128, 128 , 0 );
    727                         else $color_t = ImageColorAllocateAlpha( $im3, 128, 128, 128 , 127 );
    728                         imagefill ($im3, 0, 0, $color_t);
    729 
    730 
    731                         imagecopy ( $im3, $im2, $dx, $dy, 0, 0, $x_m, $y_m);
     771                        @imagesavealpha($im3, true);
     772                        if ($mode == "masque") {
     773                                $color_t = ImageColorAllocateAlpha($im3, 128, 128, 128, 0);
     774                        } else {
     775                                $color_t = ImageColorAllocateAlpha($im3, 128, 128, 128, 127);
     776                        }
     777                        imagefill($im3, 0, 0, $color_t);
     778
     779
     780                        imagecopy($im3, $im2, $dx, $dy, 0, 0, $x_m, $y_m);
    732781
    733782                        imagedestroy($im2);
    734783                        $im2 = imagecreatetruecolor($x_i, $y_i);
    735784                        @imagealphablending($im2, false);
    736                         @imagesavealpha($im2,true);
    737 
    738                         imagecopy ( $im2, $im3, 0, 0, 0, 0, $x_i, $y_i);
     785                        @imagesavealpha($im2, true);
     786
     787                        imagecopy($im2, $im3, 0, 0, 0, 0, $x_i, $y_i);
    739788                        imagedestroy($im3);
    740789                        $x_m = $x_i;
     
    743792
    744793
    745                 $rapport = $x_i / $x_m;
    746                 if (($y_i / $y_m) < $rapport ) {
    747                         $rapport = $y_i / $y_m;
    748                 }
    749                        
    750                 $x_d = ceil($x_i / $rapport);
    751                 $y_d = ceil($y_i / $rapport);
     794                $rapport = $x_i/$x_m;
     795                if (($y_i/$y_m) < $rapport) {
     796                        $rapport = $y_i/$y_m;
     797                }
     798
     799                $x_d = ceil($x_i/$rapport);
     800                $y_d = ceil($y_i/$rapport);
    752801
    753802
     
    760809                        $x_dest = $x_m;
    761810                        $y_dest = $y_m;
    762                         $x_dec = round(($x_d - $x_m) /2);
    763                         $y_dec = round(($y_d - $y_m) /2);
    764                 }
    765 
    766 
    767                 $nouveau = _image_valeurs_trans(image_reduire($im, $x_d, $y_d),"");
    768                 if (!is_array($nouveau)) return("");
     811                        $x_dec = round(($x_d-$x_m)/2);
     812                        $y_dec = round(($y_d-$y_m)/2);
     813                }
     814
     815
     816                $nouveau = _image_valeurs_trans(image_reduire($im, $x_d, $y_d), "");
     817                if (!is_array($nouveau)) {
     818                        return ("");
     819                }
    769820                $im_n = $nouveau["fichier"];
    770821
     
    772823                $im = $nouveau["fonction_imagecreatefrom"]($im_n);
    773824                imagepalettetotruecolor($im);
    774                 if ($nouveau["format_source"] == "gif" AND function_exists('ImageCopyResampled')) { 
     825                if ($nouveau["format_source"] == "gif" AND function_exists('ImageCopyResampled')) {
    775826                        $im_ = imagecreatetruecolor($x_dest, $y_dest);
    776827                        // Si un GIF est transparent,
    777828                        // fabriquer un PNG transparent 
    778829                        // Conserver la transparence
    779                         if (function_exists("imageAntiAlias")) imageAntiAlias($im_,true);
    780                         @imagealphablending($im_, false);
    781                         @imagesavealpha($im_,true);
     830                        if (function_exists("imageAntiAlias")) {
     831                                imageAntiAlias($im_, true);
     832                        }
     833                        @imagealphablending($im_, false);
     834                        @imagesavealpha($im_, true);
    782835                        @ImageCopyResampled($im_, $im, 0, 0, 0, 0, $x_dest, $y_dest, $x_dest, $y_dest);
    783836                        imagedestroy($im);
     
    786839                $im_ = imagecreatetruecolor($x_dest, $y_dest);
    787840                @imagealphablending($im_, false);
    788                 @imagesavealpha($im_,true);
    789                 $color_t = ImageColorAllocateAlpha( $im_, 255, 255, 255 , 127 );
    790                 imagefill ($im_, 0, 0, $color_t);
     841                @imagesavealpha($im_, true);
     842                $color_t = ImageColorAllocateAlpha($im_, 255, 255, 255, 127);
     843                imagefill($im_, 0, 0, $color_t);
    791844
    792845
    793846                // calcul couleurs de chaque pixel selon les modes de fusion
    794847                for ($x = 0; $x < $x_dest; $x++) {
    795                         for ($y=0; $y < $y_dest; $y++) {
     848                        for ($y = 0; $y < $y_dest; $y++) {
    796849                                $rgb = ImageColorAt($im2, $x, $y); // image au dessus
    797850                                $a = ($rgb >> 24) & 0xFF;
     
    807860
    808861                                if ($mode == "normal") {
    809                                         $v = (127 - $a) / 127;
     862                                        $v = (127-$a)/127;
    810863                                        if ($v == 1) {
    811864                                                $r_ = $r;
     
    813866                                                $b_ = $b;
    814867                                        } else {
    815                                                 $v2 = (127 - $a2) / 127;
     868                                                $v2 = (127-$a2)/127;
    816869                                                if ($v+$v2 == 0) {
    817870                                                        $r_ = $r2;
    818871                                                        $g_ = $g2;
    819872                                                        $b_ = $b2;
    820                                                 } else if ($v2 == 0) {
    821                                                         $r_ = $r;
    822                                                         $g_ = $g;
    823                                                         $b_ = $b;
    824                                                 } else if ($v == 0) {
    825                                                         $r_ = $r2;
    826                                                         $g_ = $g2;
    827                                                         $b_ = $b2;
    828                                                 }else {
    829                                                         $r_ = $r + (($r2 - $r) * $v2 * (1 - $v));
    830                                                         $g_ = $g + (($g2 - $g) * $v2 * (1 - $v));
    831                                                         $b_ = $b + (($b2 - $b) * $v2 * (1 - $v));
     873                                                } else {
     874                                                        if ($v2 == 0) {
     875                                                                $r_ = $r;
     876                                                                $g_ = $g;
     877                                                                $b_ = $b;
     878                                                        } else {
     879                                                                if ($v == 0) {
     880                                                                        $r_ = $r2;
     881                                                                        $g_ = $g2;
     882                                                                        $b_ = $b2;
     883                                                                } else {
     884                                                                        $r_ = $r+(($r2-$r)*$v2*(1-$v));
     885                                                                        $g_ = $g+(($g2-$g)*$v2*(1-$v));
     886                                                                        $b_ = $b+(($b2-$b)*$v2*(1-$v));
     887                                                                }
     888                                                        }
    832889                                                }
    833890                                        }
    834                                         $a_ = min($a,$a2);
    835 
    836                                 } elseif (in_array($mode, array("produit","difference","superposer","lumiere_dure","ecran"))) {
     891                                        $a_ = min($a, $a2);
     892
     893                                } elseif (in_array($mode, array("produit", "difference", "superposer", "lumiere_dure", "ecran"))) {
    837894                                        if ($mode == "produit") {
    838                                                 $r = ($r/255) * $r2;
    839                                                 $g = ($g/255) * $g2;
    840                                                 $b = ($b/255) * $b2;
     895                                                $r = ($r/255)*$r2;
     896                                                $g = ($g/255)*$g2;
     897                                                $b = ($b/255)*$b2;
    841898                                        } elseif ($mode == "difference") {
    842899                                                $r = abs($r-$r2);
     
    844901                                                $b = abs($b-$b2);
    845902                                        } elseif ($mode == "superposer") {
    846                                                 $r = ($r2 < 128) ? 2 * $r * $r2 / 255 : 255 - (2 * (255 - $r) * (255 - $r2) / 255);
    847                                                 $g = ($g2 < 128) ? 2 * $g * $g2 / 255 : 255 - (2 * (255 - $g) * (255 - $g2) / 255);
    848                                                 $b = ($b2 < 128) ? 2 * $b * $b2 / 255 : 255 - (2 * (255 - $b) * (255 - $b2) / 255);
     903                                                $r = ($r2 < 128) ? 2*$r*$r2/255 : 255-(2*(255-$r)*(255-$r2)/255);
     904                                                $g = ($g2 < 128) ? 2*$g*$g2/255 : 255-(2*(255-$g)*(255-$g2)/255);
     905                                                $b = ($b2 < 128) ? 2*$b*$b2/255 : 255-(2*(255-$b)*(255-$b2)/255);
    849906                                        } elseif ($mode == "lumiere_dure") {
    850                                                 $r = ($r < 128) ? 2 * $r * $r2 / 255 : 255 - (2 * (255 - $r2) * (255 - $r) / 255);
    851                                                 $g = ($g < 128) ? 2 * $g * $g2 / 255 : 255 - (2 * (255 - $g2) * (255 - $g) / 255);
    852                                                 $b = ($b < 128) ? 2 * $b * $b2 / 255 : 255 - (2 * (255 - $b2) * (255 - $b) / 255);
     907                                                $r = ($r < 128) ? 2*$r*$r2/255 : 255-(2*(255-$r2)*(255-$r)/255);
     908                                                $g = ($g < 128) ? 2*$g*$g2/255 : 255-(2*(255-$g2)*(255-$g)/255);
     909                                                $b = ($b < 128) ? 2*$b*$b2/255 : 255-(2*(255-$b2)*(255-$b)/255);
    853910                                        } elseif ($mode == "ecran") {
    854                                                 $r = 255 - (((255 - $r) * (255 - $r2)) / 255);
    855                                                 $g = 255 - (((255 - $g) * (255 - $g2)) / 255);
    856                                                 $b = 255 - (((255 - $b) * (255 - $b2)) / 255);
     911                                                $r = 255-(((255-$r)*(255-$r2))/255);
     912                                                $g = 255-(((255-$g)*(255-$g2))/255);
     913                                                $b = 255-(((255-$b)*(255-$b2))/255);
    857914                                        }
    858915                                        $r = max(0, min($r, 255));
     
    861918
    862919                                        // melange en fonction de la transparence du masque
    863                                         $v = (127 - $a) / 127;
     920                                        $v = (127-$a)/127;
    864921                                        if ($v == 1) { // melange complet
    865922                                                $r_ = $r;
     
    867924                                                $b_ = $b;
    868925                                        } else {
    869                                                 $v2 = (127 - $a2) / 127;
     926                                                $v2 = (127-$a2)/127;
    870927                                                if ($v+$v2 == 0) { // ??
    871928                                                        $r_ = $r2;
     
    873930                                                        $b_ = $b2;
    874931                                                } else { // pas de melange (transparence du masque)
    875                                                         $r_ = $r + (($r2 - $r) * $v2 * (1 - $v));
    876                                                         $g_ = $g + (($g2 - $g) * $v2 * (1 - $v));
    877                                                         $b_ = $b + (($b2 - $b) * $v2 * (1 - $v));
     932                                                        $r_ = $r+(($r2-$r)*$v2*(1-$v));
     933                                                        $g_ = $g+(($g2-$g)*$v2*(1-$v));
     934                                                        $b_ = $b+(($b2-$b)*$v2*(1-$v));
    878935                                                }
    879936                                        }
     
    881938
    882939                                } elseif ($mode == "eclaircir" OR $mode == "obscurcir") {
    883                                         $v = (127 - $a) / 127;
     940                                        $v = (127-$a)/127;
    884941                                        if ($v == 1) {
    885942                                                $r_ = $r;
     
    887944                                                $b_ = $b;
    888945                                        } else {
    889                                                 $v2 = (127 - $a2) / 127;
     946                                                $v2 = (127-$a2)/127;
    890947                                                if ($v+$v2 == 0) {
    891948                                                        $r_ = $r2;
     
    893950                                                        $b_ = $b2;
    894951                                                } else {
    895                                                         $r_ = $r + (($r2 - $r) * $v2 * (1 - $v));
    896                                                         $g_ = $g + (($g2 - $g) * $v2 * (1 - $v));
    897                                                         $b_ = $b + (($b2 - $b) * $v2 * (1 - $v));
     952                                                        $r_ = $r+(($r2-$r)*$v2*(1-$v));
     953                                                        $g_ = $g+(($g2-$g)*$v2*(1-$v));
     954                                                        $b_ = $b+(($b2-$b)*$v2*(1-$v));
    898955                                                }
    899956                                        }
    900957                                        if ($mode == "eclaircir") {
    901                                                 $r_ = max ($r_, $r2);
    902                                                 $g_ = max ($g_, $g2);
    903                                                 $b_ = max ($b_, $b2);
     958                                                $r_ = max($r_, $r2);
     959                                                $g_ = max($g_, $g2);
     960                                                $b_ = max($b_, $b2);
    904961                                        } else {
    905                                                 $r_ = min ($r_, $r2);
    906                                                 $g_ = min ($g_, $g2);
    907                                                 $b_ = min ($b_, $b2);
     962                                                $r_ = min($r_, $r2);
     963                                                $g_ = min($g_, $g2);
     964                                                $b_ = min($b_, $b2);
    908965                                        }
    909                                         $a_ = min($a,$a2);
    910 
    911                                 } elseif (in_array($mode, array("teinte","saturation","valeur"))) {
     966                                        $a_ = min($a, $a2);
     967
     968                                } elseif (in_array($mode, array("teinte", "saturation", "valeur"))) {
    912969                                        include_spip("filtres/images_lib");
    913970                                        $hsv = _couleur_rgb2hsv($r, $g, $b); // image au dessus
     
    919976                                        $s2 = $hsv2["s"];
    920977                                        $v2 = $hsv2["v"];
    921                                         switch ($mode)  {
     978                                        switch ($mode) {
    922979                                                case "teinte";
    923980                                                        $rgb3 = _couleur_hsv2rgb($h, $s2, $v2);
     
    935992
    936993                                        // melange en fonction de la transparence du masque
    937                                         $v = (127 - $a) / 127;
     994                                        $v = (127-$a)/127;
    938995                                        if ($v == 1) { // melange complet
    939996                                                $r_ = $r;
     
    941998                                                $b_ = $b;
    942999                                        } else {
    943                                                 $v2 = (127 - $a2) / 127;
     1000                                                $v2 = (127-$a2)/127;
    9441001                                                if ($v+$v2 == 0) { // ??
    9451002                                                        $r_ = $r2;
     
    9471004                                                        $b_ = $b2;
    9481005                                                } else { // pas de melange (transparence du masque)
    949                                                         $r_ = $r + (($r2 - $r) * $v2 * (1 - $v));
    950                                                         $g_ = $g + (($g2 - $g) * $v2 * (1 - $v));
    951                                                         $b_ = $b + (($b2 - $b) * $v2 * (1 - $v));
     1006                                                        $r_ = $r+(($r2-$r)*$v2*(1-$v));
     1007                                                        $g_ = $g+(($g2-$g)*$v2*(1-$v));
     1008                                                        $b_ = $b+(($b2-$b)*$v2*(1-$v));
    9521009                                                }
    9531010                                        }
     
    9551012
    9561013                                } else {
    957                                         $r_ = $r2 + 1 * ($r - 127);
     1014                                        $r_ = $r2+1*($r-127);
    9581015                                        $r_ = max(0, min($r_, 255));
    959                                         $g_ = $g2 + 1 * ($g - 127);
     1016                                        $g_ = $g2+1*($g-127);
    9601017                                        $g_ = max(0, min($g_, 255));
    961                                         $b_ = $b2 + 1 * ($b - 127);
     1018                                        $b_ = $b2+1*($b-127);
    9621019                                        $b_ = max(0, min($b_, 255));
    963                                         $a_ = $a + $a2 - round($a*$a2/127);
    964                                 }
    965 
    966                                 $color = ImageColorAllocateAlpha( $im_, $r_, $g_, $b_ , $a_ );
    967                                 imagesetpixel ($im_, $x, $y, $color);
    968                         }
    969                 }
    970 
    971                 _image_gd_output($im_,$image);
     1020                                        $a_ = $a+$a2-round($a*$a2/127);
     1021                                }
     1022
     1023                                $color = ImageColorAllocateAlpha($im_, $r_, $g_, $b_, $a_);
     1024                                imagesetpixel($im_, $x, $y, $color);
     1025                        }
     1026                }
     1027
     1028                _image_gd_output($im_, $image);
    9721029                imagedestroy($im_);
    9731030                imagedestroy($im);
     
    9771034        $x_dest = largeur($dest);
    9781035        $y_dest = hauteur($dest);
    979         return _image_ecrire_tag($image,array('src'=>$dest,'width'=>$x_dest,'height'=>$y_dest));
     1036
     1037        return _image_ecrire_tag($image, array('src' => $dest, 'width' => $x_dest, 'height' => $y_dest));
    9801038}
    9811039
     
    9851043// on peut ici regler cette ponderation en "pour mille"
    9861044// http://code.spip.net/@image_nb
    987 function image_nb($im, $val_r = 299, $val_g = 587, $val_b = 114)
    988 {
     1045function image_nb($im, $val_r = 299, $val_g = 587, $val_b = 114) {
    9891046        $fonction = array('image_nb', func_get_args());
    990         $image = _image_valeurs_trans($im, "nb-$val_r-$val_g-$val_b",false,$fonction);
    991         if (!$image) return("");
    992        
     1047        $image = _image_valeurs_trans($im, "nb-$val_r-$val_g-$val_b", false, $fonction);
     1048        if (!$image) {
     1049                return ("");
     1050        }
     1051
    9931052        $x_i = $image["largeur"];
    9941053        $y_i = $image["hauteur"];
    995        
     1054
    9961055        $im = $image["fichier"];
    9971056        $dest = $image["fichier_dest"];
    998        
     1057
    9991058        $creer = $image["creer"];
    1000        
     1059
    10011060        // Methode precise
    10021061        // resultat plus beau, mais tres lourd
     
    10101069                $im_ = imagecreatetruecolor($x_i, $y_i);
    10111070                @imagealphablending($im_, false);
    1012                 @imagesavealpha($im_,true);
    1013                 $color_t = ImageColorAllocateAlpha( $im_, 255, 255, 255 , 127 );
    1014                 imagefill ($im_, 0, 0, $color_t);
     1071                @imagesavealpha($im_, true);
     1072                $color_t = ImageColorAllocateAlpha($im_, 255, 255, 255, 127);
     1073                imagefill($im_, 0, 0, $color_t);
    10151074                imagecopy($im_, $im, 0, 0, 0, 0, $x_i, $y_i);
    1016                
     1075
    10171076                for ($x = 0; $x < $x_i; $x++) {
    1018                         for ($y=0; $y < $y_i; $y++) {
     1077                        for ($y = 0; $y < $y_i; $y++) {
    10191078                                $rgb = ImageColorAt($im_, $x, $y);
    10201079                                $a = ($rgb >> 24) & 0xFF;
     
    10231082                                $b = $rgb & 0xFF;
    10241083
    1025                                 $c = round(($val_r * $r / 1000) + ($val_g * $g / 1000) + ($val_b * $b / 1000));
    1026                                 if ($c < 0) $c = 0;
    1027                                 if ($c > 254) $c = 254;
    1028                                
    1029                                
    1030                                 $color = ImageColorAllocateAlpha( $im_, $c, $c, $c , $a );
    1031                                 imagesetpixel ($im_, $x, $y, $color);                   
    1032                         }
    1033                 }
    1034                 _image_gd_output($im_,$image);
     1084                                $c = round(($val_r*$r/1000)+($val_g*$g/1000)+($val_b*$b/1000));
     1085                                if ($c < 0) {
     1086                                        $c = 0;
     1087                                }
     1088                                if ($c > 254) {
     1089                                        $c = 254;
     1090                                }
     1091
     1092
     1093                                $color = ImageColorAllocateAlpha($im_, $c, $c, $c, $a);
     1094                                imagesetpixel($im_, $x, $y, $color);
     1095                        }
     1096                }
     1097                _image_gd_output($im_, $image);
    10351098                imagedestroy($im_);
    10361099                imagedestroy($im);
    10371100        }
    10381101
    1039         return _image_ecrire_tag($image,array('src'=>$dest));
     1102        return _image_ecrire_tag($image, array('src' => $dest));
    10401103}
    10411104
    10421105// http://code.spip.net/@image_flou
    1043 function image_flou($im, $niveau = 3)
    1044 {
     1106function image_flou($im, $niveau = 3) {
    10451107        // Il s'agit d'une modification du script blur qu'on trouve un peu partout:
    10461108        // + la transparence est geree correctement
    10471109        // + les dimensions de l'image sont augmentees pour flouter les bords
    1048         $coeffs = array (
    1049                                 array ( 1),
    1050                                 array ( 1, 1),
    1051                                 array ( 1, 2, 1),
    1052                                 array ( 1, 3, 3, 1),
    1053                                 array ( 1, 4, 6, 4, 1),
    1054                                 array ( 1, 5, 10, 10, 5, 1),
    1055                                 array ( 1, 6, 15, 20, 15, 6, 1),
    1056                                 array ( 1, 7, 21, 35, 35, 21, 7, 1),
    1057                                 array ( 1, 8, 28, 56, 70, 56, 28, 8, 1),
    1058                                 array ( 1, 9, 36, 84, 126, 126, 84, 36, 9, 1),
    1059                                 array ( 1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1),
    1060                                 array ( 1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1)
    1061                                 );
    1062        
     1110        $coeffs = array(
     1111                array(1),
     1112                array(1, 1),
     1113                array(1, 2, 1),
     1114                array(1, 3, 3, 1),
     1115                array(1, 4, 6, 4, 1),
     1116                array(1, 5, 10, 10, 5, 1),
     1117                array(1, 6, 15, 20, 15, 6, 1),
     1118                array(1, 7, 21, 35, 35, 21, 7, 1),
     1119                array(1, 8, 28, 56, 70, 56, 28, 8, 1),
     1120                array(1, 9, 36, 84, 126, 126, 84, 36, 9, 1),
     1121                array(1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1),
     1122                array(1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1)
     1123        );
     1124
    10631125        $fonction = array('image_flou', func_get_args());
    1064         $image = _image_valeurs_trans($im, "flou-$niveau", false,$fonction);
    1065         if (!$image) return("");
    1066        
     1126        $image = _image_valeurs_trans($im, "flou-$niveau", false, $fonction);
     1127        if (!$image) {
     1128                return ("");
     1129        }
     1130
    10671131        $x_i = $image["largeur"];
    10681132        $y_i = $image["hauteur"];
    1069         $sum = pow (2, $niveau);
     1133        $sum = pow(2, $niveau);
    10701134
    10711135        $im = $image["fichier"];
    10721136        $dest = $image["fichier_dest"];
    1073        
     1137
    10741138        $creer = $image["creer"];
    1075        
     1139
    10761140        // Methode precise
    10771141        // resultat plus beau, mais tres lourd
     
    10851149                $temp1 = imagecreatetruecolor($x_i+$niveau, $y_i);
    10861150                $temp2 = imagecreatetruecolor($x_i+$niveau, $y_i+$niveau);
    1087                
     1151
    10881152                @imagealphablending($temp1, false);
    1089                 @imagesavealpha($temp1,true);
     1153                @imagesavealpha($temp1, true);
    10901154                @imagealphablending($temp2, false);
    1091                 @imagesavealpha($temp2,true);
    1092 
    1093                
     1155                @imagesavealpha($temp2, true);
     1156
     1157
    10941158                for ($i = 0; $i < $x_i+$niveau; $i++) {
    1095                         for ($j=0; $j < $y_i; $j++) {
    1096                                 $suma=0;
    1097                                 $sumr=0;
    1098                                 $sumg=0;
    1099                                 $sumb=0;
     1159                        for ($j = 0; $j < $y_i; $j++) {
     1160                                $suma = 0;
     1161                                $sumr = 0;
     1162                                $sumg = 0;
     1163                                $sumb = 0;
    11001164                                $sum = 0;
    11011165                                $sum_ = 0;
    1102                                 for ( $k=0 ; $k <= $niveau ; ++$k ) {
    1103                                         $color = imagecolorat($im, $i_ = ($i-$niveau)+$k , $j);
     1166                                for ($k = 0; $k <= $niveau; ++$k) {
     1167                                        $color = imagecolorat($im, $i_ = ($i-$niveau)+$k, $j);
    11041168
    11051169                                        $a = ($color >> 24) & 0xFF;
     
    11071171                                        $g = ($color >> 8) & 0xFF;
    11081172                                        $b = ($color) & 0xFF;
    1109                                        
    1110                                         if ($i_ < 0 OR $i_ >= $x_i) $a = 127;
    1111                                        
     1173
     1174                                        if ($i_ < 0 OR $i_ >= $x_i) {
     1175                                                $a = 127;
     1176                                        }
     1177
    11121178                                        $coef = $coeffs[$niveau][$k];
    11131179                                        $suma += $a*$coef;
    1114                                         $ac = ((127-$a) / 127);
    1115                                        
     1180                                        $ac = ((127-$a)/127);
     1181
    11161182                                        $ac = $ac*$ac;
    1117                                        
    1118                                         $sumr += $r * $coef * $ac;
    1119                                         $sumg += $g * $coef * $ac;
    1120                                         $sumb += $b * $coef * $ac;
    1121                                         $sum += $coef * $ac;
     1183
     1184                                        $sumr += $r*$coef*$ac;
     1185                                        $sumg += $g*$coef*$ac;
     1186                                        $sumb += $b*$coef*$ac;
     1187                                        $sum += $coef*$ac;
    11221188                                        $sum_ += $coef;
    11231189                                }
    1124                                 if ($sum > 0) $color = ImageColorAllocateAlpha ($temp1, $sumr/$sum, $sumg/$sum, $sumb/$sum, $suma/$sum_);
    1125                                 else $color = ImageColorAllocateAlpha ($temp1, 255, 255, 255, 127);
    1126                                 imagesetpixel($temp1,$i,$j,$color);
     1190                                if ($sum > 0) {
     1191                                        $color = ImageColorAllocateAlpha($temp1, $sumr/$sum, $sumg/$sum, $sumb/$sum, $suma/$sum_);
     1192                                } else {
     1193                                        $color = ImageColorAllocateAlpha($temp1, 255, 255, 255, 127);
     1194                                }
     1195                                imagesetpixel($temp1, $i, $j, $color);
    11271196                        }
    11281197                }
    11291198                imagedestroy($im);
    11301199                for ($i = 0; $i < $x_i+$niveau; $i++) {
    1131                         for ($j=0; $j < $y_i+$niveau; $j++) {
    1132                                 $suma=0;
    1133                                 $sumr=0;
    1134                                 $sumg=0;
    1135                                 $sumb=0;
     1200                        for ($j = 0; $j < $y_i+$niveau; $j++) {
     1201                                $suma = 0;
     1202                                $sumr = 0;
     1203                                $sumg = 0;
     1204                                $sumb = 0;
    11361205                                $sum = 0;
    11371206                                $sum_ = 0;
    1138                                 for ( $k=0 ; $k <= $niveau ; ++$k ) {
     1207                                for ($k = 0; $k <= $niveau; ++$k) {
    11391208                                        $color = imagecolorat($temp1, $i, $j_ = $j-$niveau+$k);
    11401209                                        $a = ($color >> 24) & 0xFF;
     
    11421211                                        $g = ($color >> 8) & 0xFF;
    11431212                                        $b = ($color) & 0xFF;
    1144                                         if ($j_ < 0 OR $j_ >= $y_i) $a = 127;
    1145                                        
     1213                                        if ($j_ < 0 OR $j_ >= $y_i) {
     1214                                                $a = 127;
     1215                                        }
     1216
    11461217                                        $suma += $a*$coeffs[$niveau][$k];
    1147                                         $ac = ((127-$a) / 127);
    1148                                                                                
    1149                                         $sumr += $r * $coeffs[$niveau][$k] * $ac;
    1150                                         $sumg += $g * $coeffs[$niveau][$k] * $ac;
    1151                                         $sumb += $b * $coeffs[$niveau][$k] * $ac;
    1152                                         $sum += $coeffs[$niveau][$k] * $ac;
     1218                                        $ac = ((127-$a)/127);
     1219
     1220                                        $sumr += $r*$coeffs[$niveau][$k]*$ac;
     1221                                        $sumg += $g*$coeffs[$niveau][$k]*$ac;
     1222                                        $sumb += $b*$coeffs[$niveau][$k]*$ac;
     1223                                        $sum += $coeffs[$niveau][$k]*$ac;
    11531224                                        $sum_ += $coeffs[$niveau][$k];
    1154                                        
    1155                                 }
    1156                                 if ($sum > 0) $color = ImageColorAllocateAlpha ($temp2, $sumr/$sum, $sumg/$sum, $sumb/$sum, $suma/$sum_);
    1157                                 else $color = ImageColorAllocateAlpha ($temp2, 255, 255, 255, 127);
    1158                                 imagesetpixel($temp2,$i,$j,$color);
    1159                         }
    1160                 }
    1161        
    1162                 _image_gd_output($temp2,$image);
    1163                 imagedestroy($temp1);   
    1164                 imagedestroy($temp2);   
    1165         }
    1166        
    1167         return _image_ecrire_tag($image,array('src'=>$dest,'width'=>($x_i+$niveau),'height'=>($y_i+$niveau)));
     1225
     1226                                }
     1227                                if ($sum > 0) {
     1228                                        $color = ImageColorAllocateAlpha($temp2, $sumr/$sum, $sumg/$sum, $sumb/$sum, $suma/$sum_);
     1229                                } else {
     1230                                        $color = ImageColorAllocateAlpha($temp2, 255, 255, 255, 127);
     1231                                }
     1232                                imagesetpixel($temp2, $i, $j, $color);
     1233                        }
     1234                }
     1235
     1236                _image_gd_output($temp2, $image);
     1237                imagedestroy($temp1);
     1238                imagedestroy($temp2);
     1239        }
     1240
     1241        return _image_ecrire_tag($image, array('src' => $dest, 'width' => ($x_i+$niveau), 'height' => ($y_i+$niveau)));
    11681242}
    11691243
     
    11711245function image_RotateBicubic($src_img, $angle, $bicubic = 0) {
    11721246        include_spip('filtres/images_lib');
    1173    
     1247
    11741248        if (round($angle/90)*90 == $angle) {
    11751249                $droit = true;
    1176                 if (round($angle/180)*180 == $angle) $rot = 180;
    1177                 else $rot = 90;
    1178         }
    1179         else
     1250                if (round($angle/180)*180 == $angle) {
     1251                        $rot = 180;
     1252                } else {
     1253                        $rot = 90;
     1254                }
     1255        } else {
    11801256                $droit = false;
    1181    
     1257        }
     1258
    11821259        // convert degrees to radians
    1183         $angle = $angle + 180;
     1260        $angle = $angle+180;
    11841261        $angle = deg2rad($angle);
    1185        
    1186        
    1187        
     1262
     1263
    11881264        $src_x = imagesx($src_img);
    11891265        $src_y = imagesy($src_img);
    1190        
    1191        
     1266
     1267
    11921268        $center_x = floor(($src_x-1)/2);
    11931269        $center_y = floor(($src_y-1)/2);
    1194        
     1270
    11951271        $cosangle = cos($angle);
    11961272        $sinangle = sin($angle);
     
    11991275        // des rotations a angle droit
    12001276        if (!$droit) {
    1201                 $corners=array(array(0,0), array($src_x,0), array($src_x,$src_y), array(0,$src_y));
    1202        
    1203                 foreach($corners as $key=>$value) {
    1204                         $value[0]-=$center_x;        //Translate coords to center for rotation
    1205                         $value[1]-=$center_y;
    1206                         $temp=array();
    1207                         $temp[0]=$value[0]*$cosangle+$value[1]*$sinangle;
    1208                         $temp[1]=$value[1]*$cosangle-$value[0]*$sinangle;
    1209                         $corners[$key]=$temp;   
    1210                 }
    1211            
    1212                 $min_x=1000000000000000;
    1213                 $max_x=-1000000000000000;
    1214                 $min_y=1000000000000000;
    1215                 $max_y=-1000000000000000;
    1216            
    1217                 foreach($corners as $key => $value) {
    1218                         if($value[0]<$min_x)
    1219                                 $min_x=$value[0];
    1220                         if($value[0]>$max_x)
    1221                                 $max_x=$value[0];
    1222                        
    1223                         if($value[1]<$min_y)
    1224                                 $min_y=$value[1];
    1225                         if($value[1]>$max_y)
    1226                                 $max_y=$value[1];
    1227           }
    1228        
    1229                 $rotate_width=ceil($max_x-$min_x);
    1230                 $rotate_height=ceil($max_y-$min_y);
    1231         }
    1232         else {
     1277                $corners = array(array(0, 0), array($src_x, 0), array($src_x, $src_y), array(0, $src_y));
     1278
     1279                foreach ($corners as $key => $value) {
     1280                        $value[0] -= $center_x;        //Translate coords to center for rotation
     1281                        $value[1] -= $center_y;
     1282                        $temp = array();
     1283                        $temp[0] = $value[0]*$cosangle+$value[1]*$sinangle;
     1284                        $temp[1] = $value[1]*$cosangle-$value[0]*$sinangle;
     1285                        $corners[$key] = $temp;
     1286                }
     1287
     1288                $min_x = 1000000000000000;
     1289                $max_x = -1000000000000000;
     1290                $min_y = 1000000000000000;
     1291                $max_y = -1000000000000000;
     1292
     1293                foreach ($corners as $key => $value) {
     1294                        if ($value[0] < $min_x) {
     1295                                $min_x = $value[0];
     1296                        }
     1297                        if ($value[0] > $max_x) {
     1298                                $max_x = $value[0];
     1299                        }
     1300
     1301                        if ($value[1] < $min_y) {
     1302                                $min_y = $value[1];
     1303                        }
     1304                        if ($value[1] > $max_y) {
     1305                                $max_y = $value[1];
     1306                        }
     1307                }
     1308
     1309                $rotate_width = ceil($max_x-$min_x);
     1310                $rotate_height = ceil($max_y-$min_y);
     1311        } else {
    12331312                if ($rot == 180) {
    12341313                        $rotate_height = $src_y;
     
    12401319                $bicubic = false;
    12411320        }
    1242        
    1243        
    1244         $rotate=imagecreatetruecolor($rotate_width,$rotate_height);
     1321
     1322
     1323        $rotate = imagecreatetruecolor($rotate_width, $rotate_height);
    12451324        imagealphablending($rotate, false);
    12461325        imagesavealpha($rotate, true);
    1247        
     1326
    12481327        $cosangle = cos($angle);
    12491328        $sinangle = sin($angle);
    1250    
     1329
    12511330        // arrondir pour rotations angle droit (car cos et sin dans {-1,0,1})
    12521331        if ($droit) {
     
    12581337        $newcenter_y = ($rotate_height-1)/2;
    12591338
    1260    
     1339
    12611340        for ($y = 0; $y < $rotate_height; $y++) {
    12621341                for ($x = 0; $x < $rotate_width; $x++) {
    12631342                        // rotate...
    1264                         $old_x = ((($newcenter_x-$x) * $cosangle + ($newcenter_y-$y) * $sinangle))
    1265                          + $center_x;
    1266                         $old_y = ((($newcenter_y-$y) * $cosangle - ($newcenter_x-$x) * $sinangle))
    1267                          + $center_y; 
    1268          
     1343                        $old_x = ((($newcenter_x-$x)*$cosangle+($newcenter_y-$y)*$sinangle))
     1344                                +$center_x;
     1345                        $old_y = ((($newcenter_y-$y)*$cosangle-($newcenter_x-$x)*$sinangle))
     1346                                +$center_y;
     1347
    12691348                        $old_x = ceil($old_x);
    12701349                        $old_y = ceil($old_y);
    1271          
    1272                         if ( $old_x >= 0 && $old_x < $src_x
    1273                          && $old_y >= 0 && $old_y < $src_y ) {
     1350
     1351                        if ($old_x >= 0 && $old_x < $src_x
     1352                                && $old_y >= 0 && $old_y < $src_y
     1353                        ) {
    12741354                                if ($bicubic == true) {
    12751355                                        $xo = $old_x;
     
    12791359                                        $y0 = floor($yo);
    12801360                                        $y1 = ceil($yo);
    1281        
     1361
    12821362                                        // on prend chaque point, mais on pondere en fonction de la distance
    1283                                         $rgb = ImageColorAt($src_img, $x0, $y0); 
     1363                                        $rgb = ImageColorAt($src_img, $x0, $y0);
    12841364                                        $a1 = ($rgb >> 24) & 0xFF;
    12851365                                        $r1 = ($rgb >> 16) & 0xFF;
     
    12871367                                        $b1 = $rgb & 0xFF;
    12881368                                        $d1 = _image_distance_pixel($xo, $yo, $x0, $y0);
    1289                                        
    1290                                         $rgb = ImageColorAt($src_img, $x1, $y0); 
     1369
     1370                                        $rgb = ImageColorAt($src_img, $x1, $y0);
    12911371                                        $a2 = ($rgb >> 24) & 0xFF;
    12921372                                        $r2 = ($rgb >> 16) & 0xFF;
     
    12941374                                        $b2 = $rgb & 0xFF;
    12951375                                        $d2 = _image_distance_pixel($xo, $yo, $x1, $y0);
    1296                                        
    1297                                         $rgb = ImageColorAt($src_img,$x0, $y1);
     1376
     1377                                        $rgb = ImageColorAt($src_img, $x0, $y1);
    12981378                                        $a3 = ($rgb >> 24) & 0xFF;
    12991379                                        $r3 = ($rgb >> 16) & 0xFF;
     
    13011381                                        $b3 = $rgb & 0xFF;
    13021382                                        $d3 = _image_distance_pixel($xo, $yo, $x0, $y1);
    1303                                        
    1304                                         $rgb = ImageColorAt($src_img,$x1, $y1);
     1383
     1384                                        $rgb = ImageColorAt($src_img, $x1, $y1);
    13051385                                        $a4 = ($rgb >> 24) & 0xFF;
    13061386                                        $r4 = ($rgb >> 16) & 0xFF;
     
    13081388                                        $b4 = $rgb & 0xFF;
    13091389                                        $d4 = _image_distance_pixel($xo, $yo, $x1, $y1);
    1310                                        
    1311                                         $ac1 = ((127-$a1) / 127);
    1312                                         $ac2 = ((127-$a2) / 127);
    1313                                         $ac3 = ((127-$a3) / 127);
    1314                                         $ac4 = ((127-$a4) / 127);
     1390
     1391                                        $ac1 = ((127-$a1)/127);
     1392                                        $ac2 = ((127-$a2)/127);
     1393                                        $ac3 = ((127-$a3)/127);
     1394                                        $ac4 = ((127-$a4)/127);
    13151395
    13161396                                        // limiter impact des couleurs transparentes,
    13171397                                        // mais attention tout transp: division par 0
    1318                                         if ($ac1*$d1 + $ac2*$d2 + $ac3+$d3 + $ac4+$d4 > 0) {
    1319                                                 if ($ac1 > 0) $d1 = $d1 * $ac1;
    1320                                                 if ($ac2 > 0) $d2 = $d2 * $ac2;
    1321                                                 if ($ac3 > 0) $d3 = $d3 * $ac3;
    1322                                                 if ($ac4 > 0) $d4 = $d4 * $ac4;
     1398                                        if ($ac1*$d1+$ac2*$d2+$ac3+$d3+$ac4+$d4 > 0) {
     1399                                                if ($ac1 > 0) {
     1400                                                        $d1 = $d1*$ac1;
     1401                                                }
     1402                                                if ($ac2 > 0) {
     1403                                                        $d2 = $d2*$ac2;
     1404                                                }
     1405                                                if ($ac3 > 0) {
     1406                                                        $d3 = $d3*$ac3;
     1407                                                }
     1408                                                if ($ac4 > 0) {
     1409                                                        $d4 = $d4*$ac4;
     1410                                                }
    13231411                                        }
    1324                                        
    1325                                         $tot  = $d1 + $d2 + $d3 + $d4;
     1412
     1413                                        $tot = $d1+$d2+$d3+$d4;
    13261414
    13271415                                        $r = round((($d1*$r1)+($d2*$r2)+($d3*$r3)+($d4*$r4))/$tot);
     
    13291417                                        $b = round((($d1*$b1+($d2*$b2)+$d3*$b3+$d4*$b4))/$tot);
    13301418                                        $a = round((($d1*$a1+($d2*$a2)+$d3*$a3+$d4*$a4))/$tot);
    1331                                         $color = imagecolorallocatealpha($src_img, $r,$g,$b,$a);
    1332                                 }
    1333                                 else {
     1419                                        $color = imagecolorallocatealpha($src_img, $r, $g, $b, $a);
     1420                                } else {
    13341421                                        $color = imagecolorat($src_img, round($old_x), round($old_y));
    13351422                                }
    1336                         }
    1337                         else {
     1423                        } else {
    13381424                                // this line sets the background colour
    13391425                                $color = imagecolorallocatealpha($src_img, 255, 255, 255, 127);
     
    13421428                }
    13431429        }
     1430
    13441431        return $rotate;
    13451432}
     
    13481435// la fonction "crop" n'est pas implementee...
    13491436// http://code.spip.net/@image_rotation
    1350 function image_rotation($im, $angle, $crop = false)
    1351 {
     1437function image_rotation($im, $angle, $crop = false) {
    13521438        $fonction = array('image_rotation', func_get_args());
    13531439        $image = _image_valeurs_trans($im, "rot-$angle-$crop", "png", $fonction);
    1354         if (!$image) return("");
    1355        
     1440        if (!$image) {
     1441                return ("");
     1442        }
     1443
    13561444        $im = $image["fichier"];
    13571445        $dest = $image["fichier_dest"];
    1358        
     1446
    13591447        $creer = $image["creer"];
    1360        
     1448
    13611449        if ($creer) {
    13621450                $effectuer_gd = true;
    13631451
    1364                 if(method_exists('Imagick','rotateImage')){
     1452                if (method_exists('Imagick', 'rotateImage')) {
    13651453                        $imagick = new Imagick();
    13661454                        $imagick->readImage($im);
     
    13681456                        $imagick->writeImage($dest);
    13691457                        $effectuer_gd = false;
    1370                 }
    1371                 else if ($GLOBALS['meta']['image_process'] == "convert") {
    1372                         if (_CONVERT_COMMAND!='') {
    1373                                 @define ('_CONVERT_COMMAND', 'convert');
    1374                                 @define ('_ROTATE_COMMAND', _CONVERT_COMMAND.' -background none -rotate %t %src %dest');
    1375                         } else
    1376                                 @define ('_ROTATE_COMMAND', '');
    1377                         if (_ROTATE_COMMAND!=='') {
    1378                                 $commande = str_replace(
    1379                                         array('%t', '%src', '%dest'),
    1380                                         array(
    1381                                                 $angle,
    1382                                                 escapeshellcmd($im),
    1383                                                 escapeshellcmd($dest)
    1384                                         ),
    1385                                         _ROTATE_COMMAND);
    1386                                 spip_log($commande);
    1387                                 exec($commande);
    1388                                 if (file_exists($dest)) // precaution
     1458                } else {
     1459                        if ($GLOBALS['meta']['image_process'] == "convert") {
     1460                                if (_CONVERT_COMMAND != '') {
     1461                                        @define('_CONVERT_COMMAND', 'convert');
     1462                                        @define('_ROTATE_COMMAND', _CONVERT_COMMAND . ' -background none -rotate %t %src %dest');
     1463                                } else {
     1464                                        @define('_ROTATE_COMMAND', '');
     1465                                }
     1466                                if (_ROTATE_COMMAND !== '') {
     1467                                        $commande = str_replace(
     1468                                                array('%t', '%src', '%dest'),
     1469                                                array(
     1470                                                        $angle,
     1471                                                        escapeshellcmd($im),
     1472                                                        escapeshellcmd($dest)
     1473                                                ),
     1474                                                _ROTATE_COMMAND);
     1475                                        spip_log($commande);
     1476                                        exec($commande);
     1477                                        if (file_exists($dest)) // precaution
     1478                                        {
     1479                                                $effectuer_gd = false;
     1480                                        }
     1481                                }
     1482                        }
     1483                        // cette variante genere-t-elle un fond transparent
     1484                        // dans les coins vide issus de la rotation ?
     1485                        elseif (function_exists('imagick_rotate')) {
     1486                                $handle = imagick_readimage($im);
     1487                                if ($handle && imagick_isopaqueimage($handle)) {
     1488                                        imagick_setfillcolor($handle, 'transparent');
     1489                                        imagick_rotate($handle, $angle);
     1490                                        imagick_writeimage($handle, $dest);
    13891491                                        $effectuer_gd = false;
    1390                         }
    1391                 }
    1392                 // cette variante genere-t-elle un fond transparent
    1393                 // dans les coins vide issus de la rotation ?
    1394                 elseif (function_exists('imagick_rotate')) {
    1395                         $handle = imagick_readimage ($im);
    1396                         if ($handle && imagick_isopaqueimage( $handle )) {
    1397                                 imagick_setfillcolor($handle, 'transparent');
    1398                                 imagick_rotate( $handle, $angle);
    1399                                 imagick_writeimage( $handle, $dest);
    1400                                 $effectuer_gd = false;
     1492                                }
    14011493                        }
    14021494                }
     
    14071499                        imagepalettetotruecolor($im);
    14081500                        $im = image_RotateBicubic($im, $angle, true);
    1409                         _image_gd_output($im,$image);
     1501                        _image_gd_output($im, $image);
    14101502                        imagedestroy($im);
    14111503                }
    14121504        }
    1413         list ($src_y,$src_x) = taille_image($dest);
    1414         return _image_ecrire_tag($image,array('src'=>$dest,'width'=>$src_x,'height'=>$src_y));
     1505        list ($src_y, $src_x) = taille_image($dest);
     1506
     1507        return _image_ecrire_tag($image, array('src' => $dest, 'width' => $src_x, 'height' => $src_y));
    14151508}
    14161509
     
    14191512// liste des fonctions: http://www.linux-nantes.org/~fmonnier/doc/imagick/
    14201513// http://code.spip.net/@image_imagick
    1421 function image_imagick () {
     1514function image_imagick() {
    14221515        $tous = func_get_args();
    14231516        $img = $tous[0];
    14241517        $fonc = $tous[1];
    1425         $tous[0]="";
     1518        $tous[0] = "";
    14261519        $tous_var = join($tous, "-");
    14271520
    14281521        $fonction = array('image_imagick', func_get_args());
    1429         $image = _image_valeurs_trans($img, "$tous_var", "png",$fonction);
    1430         if (!$image) return("");
    1431        
     1522        $image = _image_valeurs_trans($img, "$tous_var", "png", $fonction);
     1523        if (!$image) {
     1524                return ("");
     1525        }
     1526
    14321527        $im = $image["fichier"];
    14331528        $dest = $image["fichier_dest"];
    1434        
     1529
    14351530        $creer = $image["creer"];
    1436        
     1531
    14371532        if ($creer) {
    14381533                if (function_exists($fonc)) {
    14391534
    1440                         $handle = imagick_readimage ($im);
     1535                        $handle = imagick_readimage($im);
    14411536                        $arr[0] = $handle;
    1442                         for ($i=2; $i < count($tous); $i++) $arr[] = $tous[$i];
     1537                        for ($i = 2; $i < count($tous); $i++) {
     1538                                $arr[] = $tous[$i];
     1539                        }
    14431540                        call_user_func_array($fonc, $arr);
    14441541                        // Creer image dans fichier temporaire, puis renommer vers "bon" fichier
    14451542                        // de facon a eviter time_out pendant creation de l'image definitive
    14461543                        $tmp = preg_replace(",[.]png$,i", "-tmp.png", $dest);
    1447                         imagick_writeimage( $handle, $tmp);
     1544                        imagick_writeimage($handle, $tmp);
    14481545                        rename($tmp, $dest);
    1449                         ecrire_fichier($dest.".src",serialize($image));
    1450                 }
    1451         }
    1452         list ($src_y,$src_x) = taille_image($dest);
    1453         return _image_ecrire_tag($image,array('src'=>$dest,'width'=>$src_x,'height'=>$src_y));
     1546                        ecrire_fichier($dest . ".src", serialize($image));
     1547                }
     1548        }
     1549        list ($src_y, $src_x) = taille_image($dest);
     1550
     1551        return _image_ecrire_tag($image, array('src' => $dest, 'width' => $src_x, 'height' => $src_y));
    14541552
    14551553}
     
    14591557// ou plus foncee (gamma < 0)
    14601558// http://code.spip.net/@image_gamma
    1461 function image_gamma($im, $gamma = 0){
     1559function image_gamma($im, $gamma = 0) {
    14621560        include_spip('filtres/images_lib');
    14631561        $fonction = array('image_gamma', func_get_args());
    1464         $image = _image_valeurs_trans($im, "gamma-$gamma",false,$fonction);
    1465         if (!$image) return("");
    1466        
     1562        $image = _image_valeurs_trans($im, "gamma-$gamma", false, $fonction);
     1563        if (!$image) {
     1564                return ("");
     1565        }
     1566
    14671567        $x_i = $image["largeur"];
    14681568        $y_i = $image["hauteur"];
    1469        
     1569
    14701570        $im = $image["fichier"];
    14711571        $dest = $image["fichier_dest"];
    1472        
     1572
    14731573        $creer = $image["creer"];
    1474        
     1574
    14751575        if ($creer) {
    14761576                // Creation de l'image en deux temps
     
    14801580                $im_ = imagecreatetruecolor($x_i, $y_i);
    14811581                @imagealphablending($im_, false);
    1482                 @imagesavealpha($im_,true);
    1483                 $color_t = ImageColorAllocateAlpha( $im_, 255, 255, 255 , 127 );
    1484                 imagefill ($im_, 0, 0, $color_t);
     1582                @imagesavealpha($im_, true);
     1583                $color_t = ImageColorAllocateAlpha($im_, 255, 255, 255, 127);
     1584                imagefill($im_, 0, 0, $color_t);
    14851585                imagecopy($im_, $im, 0, 0, 0, 0, $x_i, $y_i);
    1486        
     1586
    14871587                for ($x = 0; $x < $x_i; $x++) {
    1488                         for ($y=0; $y < $y_i; $y++) {
     1588                        for ($y = 0; $y < $y_i; $y++) {
    14891589                                $rgb = ImageColorAt($im_, $x, $y);
    14901590                                $a = ($rgb >> 24) & 0xFF;
     
    14971597                                $b = _image_decale_composante($b, $gamma);
    14981598
    1499                                 $color = ImageColorAllocateAlpha( $im_, $r, $g, $b , $a );
    1500                                 imagesetpixel ($im_, $x, $y, $color);                   
    1501                         }
    1502                 }
    1503                 _image_gd_output($im_,$image);
    1504         }
    1505         return _image_ecrire_tag($image,array('src'=>$dest));
     1599                                $color = ImageColorAllocateAlpha($im_, $r, $g, $b, $a);
     1600                                imagesetpixel($im_, $x, $y, $color);
     1601                        }
     1602                }
     1603                _image_gd_output($im_, $image);
     1604        }
     1605
     1606        return _image_ecrire_tag($image, array('src' => $dest));
    15061607}
    15071608
     
    15111612//function image_sepia($im, $dr = 137, $dv = 111, $db = 94)
    15121613// http://code.spip.net/@image_sepia
    1513 function image_sepia($im, $rgb = "896f5e"){
     1614function image_sepia($im, $rgb = "896f5e") {
    15141615        include_spip('filtres/images_lib');
    1515        
    1516         if (!function_exists("imagecreatetruecolor")) return $im;
    1517        
     1616
     1617        if (!function_exists("imagecreatetruecolor")) {
     1618                return $im;
     1619        }
     1620
    15181621        $couleurs = _couleur_hex_to_dec($rgb);
    1519         $dr= $couleurs["red"];
    1520         $dv= $couleurs["green"];
    1521         $db= $couleurs["blue"];
    1522                
     1622        $dr = $couleurs["red"];
     1623        $dv = $couleurs["green"];
     1624        $db = $couleurs["blue"];
     1625
    15231626        $fonction = array('image_sepia', func_get_args());
    1524         $image = _image_valeurs_trans($im, "sepia-$dr-$dv-$db",false,$fonction);
    1525         if (!$image) return("");
    1526        
     1627        $image = _image_valeurs_trans($im, "sepia-$dr-$dv-$db", false, $fonction);
     1628        if (!$image) {
     1629                return ("");
     1630        }
     1631
    15271632        $x_i = $image["largeur"];
    15281633        $y_i = $image["hauteur"];
    1529        
     1634
    15301635        $im = $image["fichier"];
    15311636        $dest = $image["fichier_dest"];
    1532        
     1637
    15331638        $creer = $image["creer"];
    1534        
     1639
    15351640        if ($creer) {
    15361641                // Creation de l'image en deux temps
     
    15401645                $im_ = imagecreatetruecolor($x_i, $y_i);
    15411646                @imagealphablending($im_, false);
    1542                 @imagesavealpha($im_,true);
    1543                 $color_t = ImageColorAllocateAlpha( $im_, 255, 255, 255 , 127 );
    1544                 imagefill ($im_, 0, 0, $color_t);
     1647                @imagesavealpha($im_, true);
     1648                $color_t = ImageColorAllocateAlpha($im_, 255, 255, 255, 127);
     1649                imagefill($im_, 0, 0, $color_t);
    15451650                imagecopy($im_, $im, 0, 0, 0, 0, $x_i, $y_i);
    1546        
     1651
    15471652                for ($x = 0; $x < $x_i; $x++) {
    1548                         for ($y=0; $y < $y_i; $y++) {
     1653                        for ($y = 0; $y < $y_i; $y++) {
    15491654                                $rgb = ImageColorAt($im_, $x, $y);
    15501655                                $a = ($rgb >> 24) & 0xFF;
     
    15531658                                $b = $rgb & 0xFF;
    15541659
    1555                                 $r = round(.299 * $r + .587 * $g + .114 * $b);
     1660                                $r = round(.299*$r+.587*$g+.114*$b);
    15561661                                $g = $r;
    15571662                                $b = $r;
     
    15621667                                $b = _image_decale_composante_127($b, $db);
    15631668
    1564                                 $color = ImageColorAllocateAlpha( $im_, $r, $g, $b , $a );
    1565                                 imagesetpixel ($im_, $x, $y, $color);                   
    1566                         }
    1567                 }
    1568                 _image_gd_output($im_,$image);
     1669                                $color = ImageColorAllocateAlpha($im_, $r, $g, $b, $a);
     1670                                imagesetpixel($im_, $x, $y, $color);
     1671                        }
     1672                }
     1673                _image_gd_output($im_, $image);
    15691674                imagedestroy($im_);
    15701675                imagedestroy($im);
    15711676        }
    1572        
    1573         return _image_ecrire_tag($image,array('src'=>$dest));
     1677
     1678        return _image_ecrire_tag($image, array('src' => $dest));
    15741679}
    15751680
     
    15831688 *     Niveau de renforcement (entre 0 et 1)
    15841689 * @return string Code HTML de l'image
    1585 **/
    1586 function image_renforcement($im, $k = 0.5)
    1587 {
     1690 **/
     1691function image_renforcement($im, $k = 0.5) {
    15881692        $fonction = array('image_flou', func_get_args());
    1589         $image = _image_valeurs_trans($im, "renforcement-$k",false,$fonction);
    1590         if (!$image) return("");
     1693        $image = _image_valeurs_trans($im, "renforcement-$k", false, $fonction);
     1694        if (!$image) {
     1695                return ("");
     1696        }
    15911697
    15921698        $x_i = $image["largeur"];
     
    16011707                $im_ = imagecreatetruecolor($x_i, $y_i);
    16021708                @imagealphablending($im_, false);
    1603                 @imagesavealpha($im_,true);
    1604                 $color_t = ImageColorAllocateAlpha( $im_, 255, 255, 255 , 127 );
     1709                @imagesavealpha($im_, true);
     1710                $color_t = ImageColorAllocateAlpha($im_, 255, 255, 255, 127);
    16051711                imagefill($im_, 0, 0, $color_t);
    16061712
    16071713                for ($x = 0; $x < $x_i; $x++) {
    1608                         for ($y=0; $y < $y_i; $y++) {
    1609 
    1610                                 $rgb[1][0]=@imagecolorat($im,$x,$y-1);
    1611                                 $rgb[0][1]=@imagecolorat($im,$x-1,$y);
    1612                                 $rgb[1][1]=@imagecolorat($im,$x,$y);
    1613                                 $rgb[2][1]=@imagecolorat($im,$x+1,$y);
    1614                                 $rgb[1][2]=@imagecolorat($im,$x,$y+1);
    1615 
    1616                                 if ($x-1 < 0) $rgb[0][1] = $rgb[1][1];
    1617                                 if ($y-1 < 0) $rgb[1][0] = $rgb[1][1];
    1618                                 if ($x+1 == $x_i) $rgb[2][1] = $rgb[1][1];
    1619                                 if ($y+1 == $y_i) $rgb[1][2] = $rgb[1][1];
     1714                        for ($y = 0; $y < $y_i; $y++) {
     1715
     1716                                $rgb[1][0] = @imagecolorat($im, $x, $y-1);
     1717                                $rgb[0][1] = @imagecolorat($im, $x-1, $y);
     1718                                $rgb[1][1] = @imagecolorat($im, $x, $y);
     1719                                $rgb[2][1] = @imagecolorat($im, $x+1, $y);
     1720                                $rgb[1][2] = @imagecolorat($im, $x, $y+1);
     1721
     1722                                if ($x-1 < 0) {
     1723                                        $rgb[0][1] = $rgb[1][1];
     1724                                }
     1725                                if ($y-1 < 0) {
     1726                                        $rgb[1][0] = $rgb[1][1];
     1727                                }
     1728                                if ($x+1 == $x_i) {
     1729                                        $rgb[2][1] = $rgb[1][1];
     1730                                }
     1731                                if ($y+1 == $y_i) {
     1732                                        $rgb[1][2] = $rgb[1][1];
     1733                                }
    16201734
    16211735                                $a = ($rgb[1][1] >> 24) & 0xFF;
    1622                                 $r = -$k *(($rgb[1][0] >> 16) & 0xFF) +
    1623                                                  -$k *(($rgb[0][1] >> 16) & 0xFF) +
    1624                                                 (1+4*$k) *(($rgb[1][1] >> 16) & 0xFF) +
    1625                                                  -$k *(($rgb[2][1] >> 16) & 0xFF) +
    1626                                                  -$k *(($rgb[1][2] >> 16) & 0xFF) ;
    1627 
    1628                                 $g = -$k *(($rgb[1][0] >> 8) & 0xFF) +
    1629                                                  -$k *(($rgb[0][1] >> 8) & 0xFF) +
    1630                                                  (1+4*$k) *(($rgb[1][1] >> 8) & 0xFF) +
    1631                                                  -$k *(($rgb[2][1] >> 8) & 0xFF) +
    1632                                                  -$k *(($rgb[1][2] >> 8) & 0xFF) ;
    1633 
    1634                                 $b = -$k *($rgb[1][0] & 0xFF) +
    1635                                                  -$k *($rgb[0][1] & 0xFF) +
    1636                                                 (1+4*$k) *($rgb[1][1] & 0xFF) +
    1637                                                  -$k *($rgb[2][1] & 0xFF) +
    1638                                                  -$k *($rgb[1][2] & 0xFF) ;
    1639 
    1640                                 $r=min(255,max(0,$r));
    1641                                 $g=min(255,max(0,$g));
    1642                                 $b=min(255,max(0,$b));
    1643 
    1644 
    1645                                 $color = ImageColorAllocateAlpha( $im_, $r, $g, $b , $a );
    1646                                 imagesetpixel ($im_, $x, $y, $color);
    1647                         }
    1648                 }
    1649                 _image_gd_output($im_,$image);
    1650         }
    1651 
    1652         return _image_ecrire_tag($image,array('src'=>$dest));
     1736                                $r = -$k*(($rgb[1][0] >> 16) & 0xFF)+
     1737                                        -$k*(($rgb[0][1] >> 16) & 0xFF)+
     1738                                        (1+4*$k)*(($rgb[1][1] >> 16) & 0xFF)+
     1739                                        -$k*(($rgb[2][1] >> 16) & 0xFF)+
     1740                                        -$k*(($rgb[1][2] >> 16) & 0xFF);
     1741
     1742                                $g = -$k*(($rgb[1][0] >> 8) & 0xFF)+
     1743                                        -$k*(($rgb[0][1] >> 8) & 0xFF)+
     1744                                        (1+4*$k)*(($rgb[1][1] >> 8) & 0xFF)+
     1745                                        -$k*(($rgb[2][1] >> 8) & 0xFF)+
     1746                                        -$k*(($rgb[1][2] >> 8) & 0xFF);
     1747
     1748                                $b = -$k*($rgb[1][0] & 0xFF)+
     1749                                        -$k*($rgb[0][1] & 0xFF)+
     1750                                        (1+4*$k)*($rgb[1][1] & 0xFF)+
     1751                                        -$k*($rgb[2][1] & 0xFF)+
     1752                                        -$k*($rgb[1][2] & 0xFF);
     1753
     1754                                $r = min(255, max(0, $r));
     1755                                $g = min(255, max(0, $g));
     1756                                $b = min(255, max(0, $b));
     1757
     1758
     1759                                $color = ImageColorAllocateAlpha($im_, $r, $g, $b, $a);
     1760                                imagesetpixel($im_, $x, $y, $color);
     1761                        }
     1762                }
     1763                _image_gd_output($im_, $image);
     1764        }
     1765
     1766        return _image_ecrire_tag($image, array('src' => $dest));
    16531767}
    1654 
    1655 
    16561768
    16571769
     
    16731785 * @return mixed|null|string
    16741786 */
    1675 function image_fond_transparent($im, $background_color, $tolerance = 12, $alpha = 127, $coeff_lissage = 7)
    1676 {
     1787function image_fond_transparent($im, $background_color, $tolerance = 12, $alpha = 127, $coeff_lissage = 7) {
    16771788        $fonction = array('image_fond_transparent', func_get_args());
    1678         $image = _image_valeurs_trans($im, "fond_transparent-$background_color-$tolerance-$coeff_lissage-$alpha", "png", $fonction);
    1679         if (!$image) return("");
    1680        
     1789        $image = _image_valeurs_trans($im, "fond_transparent-$background_color-$tolerance-$coeff_lissage-$alpha", "png",
     1790                $fonction);
     1791        if (!$image) {
     1792                return ("");
     1793        }
     1794
    16811795        $x_i = $image["largeur"];
    16821796        $y_i = $image["hauteur"];
    1683        
     1797
    16841798        $im = $image["fichier"];
    16851799        $dest = $image["fichier_dest"];
    1686        
     1800
    16871801        $creer = $image["creer"];
    1688        
     1802
    16891803        if ($creer) {
    16901804                $bg = _couleur_hex_to_dec($background_color);
     
    16921806                $bg_g = $bg['green'];
    16931807                $bg_b = $bg['blue'];
    1694        
     1808
    16951809                // Creation de l'image en deux temps
    16961810                // de facon a conserver les GIF transparents
     
    16991813                $im2 = imagecreatetruecolor($x_i, $y_i);
    17001814                @imagealphablending($im2, false);
    1701                 @imagesavealpha($im2,true);
    1702                 $color_t = ImageColorAllocateAlpha( $im2, 255, 255, 255 , 127 );
    1703                 imagefill ($im2, 0, 0, $color_t);
     1815                @imagesavealpha($im2, true);
     1816                $color_t = ImageColorAllocateAlpha($im2, 255, 255, 255, 127);
     1817                imagefill($im2, 0, 0, $color_t);
    17041818                imagecopy($im2, $im, 0, 0, 0, 0, $x_i, $y_i);
    17051819
    17061820                $im_ = imagecreatetruecolor($x_i, $y_i);
    1707                 imagealphablending ($im_, FALSE );
    1708                 imagesavealpha ( $im_, TRUE );
    1709                 $color_f = ImageColorAllocateAlpha( $im_, 255, 255, 255 , $alpha );
     1821                imagealphablending($im_, false);
     1822                imagesavealpha($im_, true);
     1823                $color_f = ImageColorAllocateAlpha($im_, 255, 255, 255, $alpha);
    17101824
    17111825                for ($x = 0; $x < $x_i; $x++) {
     
    17151829                                $g = ($rgb >> 8) & 0xFF;
    17161830                                $b = $rgb & 0xFF;
    1717                                 if ((($d=abs($r-$bg_r)+abs($g-$bg_g)+abs($b-$bg_b))<=$tolerance)){
    1718                                         imagesetpixel ( $im_, $x, $y, $color_f );
    1719                                 }
    1720                                 elseif ($tolerance AND $d<=($coeff_lissage+1)*$tolerance){
     1831                                if ((($d = abs($r-$bg_r)+abs($g-$bg_g)+abs($b-$bg_b)) <= $tolerance)) {
     1832                                        imagesetpixel($im_, $x, $y, $color_f);
     1833                                } elseif ($tolerance AND $d <= ($coeff_lissage+1)*$tolerance) {
    17211834                                        $transp = round($alpha*(1-($d-$tolerance)/($coeff_lissage*$tolerance)));
    1722                                         $color_p = ImageColorAllocateAlpha( $im_, $r, $g, $b , $transp);                                       
    1723                                         imagesetpixel ( $im_, $x, $y, $color_p );
    1724                                 }
    1725                                 else
    1726                                         imagesetpixel ( $im_, $x, $y, $rgb );
    1727                         }
    1728                 }
    1729                 _image_gd_output($im_,$image);
     1835                                        $color_p = ImageColorAllocateAlpha($im_, $r, $g, $b, $transp);
     1836                                        imagesetpixel($im_, $x, $y, $color_p);
     1837                                } else {
     1838                                        imagesetpixel($im_, $x, $y, $rgb);
     1839                                }
     1840                        }
     1841                }
     1842                _image_gd_output($im_, $image);
    17301843                imagedestroy($im_);
    17311844                imagedestroy($im);
     
    17331846        }
    17341847
    1735         return _image_ecrire_tag($image,array('src'=>$dest));
     1848        return _image_ecrire_tag($image, array('src' => $dest));
    17361849}
     1850
    17371851?>
Note: See TracChangeset for help on using the changeset viewer.