Module Arithmetique
Copyright (c) 2003-2004 Benjamin FOURNIER
Version 2.2.3 multi-langues avec icône
Langue originale : Anglais
Langues complémentaires : Français
Pour tout renseignement concernant ce plugin: pluginsphotofiltre@yahoo.fr

Traduction
==========

Si vous désirez traduire ce plugin dans une autre langue envoyez moi un e-mail à pluginsphotofiltre@yahoo.fr 

If you want to translate this plugin in another language please send me an e-mail to pluginsphotofiltre@yahoo.fr

Licence
=======

La licence de PhotoFiltre est applicable pour ce plugin (à l'exception du fait qu'il n'y a pas d'enregistrement spécifique pour ce plugin)

Description
===========

Module externe (plugin) pour PhotoFiltre
Copyright (c) 2001-2003 Antonio DA CRUZ 
Site Web : http://www.photofiltre.com
Permet d'effectuer de l'arithmétique entre plusieurs images et/ou des couleurs

Installation
============

Décompressez le fichier 'Arithmetique.pfl' dans le dossier 'Plugins' de PhotoFiltre.
Redémarrez ensuite PhotoFiltre pour charger le module.

Utilisation
===========

Ce module est un module de type Outil
 il apparaît dans le menu Outils/Autre sous le nom Arithmétique...

Ce module n'est disponible que si il y a au moins une image ouverte.

Il suffit d'écrire l'expression désirée (par exemple (I1+I2)/2) en utilisant les opérateurs, les fonctions, les couleurs et les images. Pour insérér une image il suffit de double cliquer sur celle ci dans l'explorateur d'image situé en bas de la fenêtre. Une fois l'expression écrite il est possible de cliquer sur Apercu pour voir le résultat. Une fois que l'on est satisfait du résultat, il suffit de cliquer sur OK pour générer la nouvelle image résultat.

Problème avec la syntaxe colorée
================================

Si vous rencontrez des problèmes avec le plugin arithmétique il y a de forte chance que cela soit du au contrôle permettant d'obtenir la syntaxe colorée. Il est possible de le désactiver en ajoutant la ligne suivante dans la section [Plugin Arithmetique] du fichier PhotoFiltre.ini :

[Plugin Arithmetique]
PasDeSyntaxe=1

Ecriture des expressions
========================

Toutes les opérations peuvent être écrites en utilisant les boutons ou en tapant intégralement au clavier.

Une expression se compose :
---------------------------

- d'images : elles sont indiquées dans l'expression sous la forme I<n> avec n compris entre 1 et le nombre d'images ouvertes. Le numéro correspond à celui indiqué dans l'explorateur d'images. Une image est insérée en double cliquant dans l'explorateur d'image.

- de couleurs : elles sont indiquées dans l'expression sous la forme #RRVVBB en hexa décimal (équivalent au code HTML d'une couleur). Une couleur peut être insérée en cliquant sur le bouton coloré. 

- de nombre entiers : ils sont obligatoirement tapés au clavier et doivent être compris en -2147483647 et +2147483647 (précision 32 bits signé)

- des 4 opérateurs usuels : + - * / Comme dans une expression arithmétique classique, la multiplication et la division sont prioritaires sur l'addition et la soustraction. La division par 0 n'est pas considérée comme une erreur mais les bornes infinies sont utilisées de la manière suivante :

si n > 0 : n / 0 vaut +2147483647
si n < 0 : n / 0 vaut -2147483647
si n = 0 : n / 0 vaut 0

- de l'opérateur exposant : ^ qui permet d'obtenir le carré, le cube etc.

- du modulo : mod qui permet d'obtenir le reste de la division entière

- des 6 opérateurs de tests : = <> < > <= >=

  Ils sont surtout utiles avec la fonction If mais peuvent être utilisés tels quel. Les opérateurs renvoient 255 (blanc) lorsque la condition est vraie et 0 (noir) sinon.

- des fonctions logiques ou binaires : and or xor not

  Ils sont surtout utiles avec la fonction If mais peuvent être utilisés tels quel.

- de parenthèses : comme dans une expression arithmétique classique elles permettent de forcer la priorité des opérateurs.

- de commentaires mono ligne avec //

- autres fonctions :

Max(x1,..,xn) : Prend le maximum des argument pour chacune des composante RVB

Par exemple :
-------------

Max(#FF0000,#00FF00,#0000FF) donne #FFFFFF


Min(x1,...,yn) : Prend le minimum des argument pour chacune des composante RVB

Par exemple :
-------------

Min(#00FFFF,#FF00FF,#FFFF00) donne #000000


MaxLum(x1,...,yn) : Prend la couleur la plus lumineuse

Par exemple :
-------------

MaxLum(#FF0000,#80FF00) donne #80FF00


MinLum(x1,...,yn) : Prend la couleur la moins lumineuse

Par exemple :
-------------

MinLum(#FF0000,#80FF00) donne #FF0000

Avg(x1,...,yn) <=> (x1+...+yn)/n

AvgRGB(x) : Renvoie la moyenne des 3 composantes RVB cela permet de transformer une image couleur en niveaux de gris

Lum(x) : Renvoie la luminance des 3 composantes RVB avec la formule 0.299R + 0.587G + 0.114B

RGB2HSL(x) : Converti une couleur RGB en son équivalent HSL

HSL2RGB(x) : Converti une couleur HSL en son équivalent RGB

RGB2YUV(x): Converti une couleur RGB en son équivalent YUV

YUV2RGB(x): Converti une couleur YUV en son équivalent RGB

R(x): Renvoi la composante rouge

G(x): Renvoi la composante verte

B(x): Renvoi la composante bleue

Abs(x): Renvoi la valeur absolue utile pour comparer des images

Root(x[,n]): Renvoi la racine n ième de x. Si n n'est pas précisé il s'agit de la racine carrée.

If(<condition>,<vrai>,<faux>) : Cette fonction permet de faire des tests conditionnels sur les points des images.

Par exemple :
-------------

If(I1>I2,#FF0000,#00FF00) donne une image rouge et verte où les points rouges représentent les points de I1 qui sont plus lumineux que ceux de I2 et où les points verts représentents les points de I1 qui sont moins lumineux (ou aussi lumineux) que ceux de I2.

X(x): Renvoi les coordonnée en X de l'image cela permet de faire des dégradés horizontaux

Y(x): Renvoi les coordonnée en Y de l'image cela permet de faire des dégradés verticaux

W(x): Renvoi la taille horizontale de l'image (utile pour inverser un dégradé horizontal)

H(x): Renvoi la taille verticale de l'image (utile pour inverser un dégradé vertical)

Stretch(x, y): Redimensionne l'image x à la taille de l'image y

BStretch(x, y): Identique à Stretch mais avec filtrage bilinéaire.

Tile(x, y): Redimensionne l'image x à la taille de l'image y en recopiant l'image autant de fois que nécessaire pour atteindre cette taille.

Scroll(x, dx, dy): Permet de décaler l'image d'un certains nombre de pixels... Ce qui disparait d'un coté réapparait de l'autre
                   dx indique le décalage horizontal (négatif = à gauche, positif = à droite)
                   dy indique le décalage vertical (négatif = en haut, positif = en bas)
                   A noter que le décalage n'est pas obligatoirement le même pour tous les points ou les composantes de l'images.
                  
Par exemple :
-------------

Scroll(I1,W(I1)/2,H(I1)/2): Décale l'image de façon à inverser les 4 coins

Scroll(I1,Y(I1),0): Décalage progressif des ligne (la premiere n'est pas décalée, la dernière de la hauteur de l'image - 1)

Scroll(I1,-X(I1),-Y(I1)): Division de la taille de l'image par 2 et extension de type motif                   

AlphaBlend(x, y, masque, max): AlphaBlending entre l'image x et l'image y en utilisant le masque et en précisant le maximum afin d'inverser le masque.

Par exemple :
-------------

AlphaBlend(I1,I2,X(I1),W(I1))

Permet de réaliser un fondu artistique entre l'image I1 et l'image I2

- de variables :

Les variables permettent de décomposer une expression complexe en plusieurs parties. Cela permet également d'éviter d'effectuer une même opération plusieurs fois ce qui permet également d'accélérer les temps de traitements.

Une variable est un identificateur commencant obligatoirement par une lettre ou le caractère '_'. Les chiffres peuvent être utilisés à partir du deuxième caractères.

Déclaration d'une variable :
----------------------------

<Nom de la variable>:<Expression>;

Utilisation d'une variable :
----------------------------

<Nom de la variable>

Permutation des images
======================

Le drag & drop est disponible sur la liste d'image ce qui permet de réordonner les images (ce qui peut être plus pratique que de changer les In dans l'expression)

Le drag & drop utilise le bouton droit de la souris.

Informations diverses
=====================

Toutes les opérations sur les images sont réalisées avec des entiers 32 bits pour chacune des composantes RVB. Les opérations sont appliquées individuellement sur chacune des 3 composantes.

Un nombre entier est considéré comme une couleur où toutes les composantes sont identiques (niveau de gris). Par exemple le nombre entier 10 est équivalent à la couleur #0A0A0A.

Lorsque une opération porte sur 2 images de tailles différentes les images sont redimensionnées vers la plus grande taille possible au fur et à mesure de l'évaluation de l'expression.

Lorsque une erreur est détectée dans l'expression un message d'erreur explicite indique la partie de l'expression qui est mal placée (ou token inattendu) ainsi que la liste des possibilités (ou token possibles) à cet endroit de l'expression. Le curseur est placé après la partie de l'expression erronée.

Les espaces, les tabulations et les sauts de lignes peuvent être utilisés pour séparer les éléments de l'expression (Exemple: I1 + I2)

Exemples d'expressions
======================

On suppose que 3 images sont ouvertes :

- Moyenne des 2 premières images :

(I1+I2)/2

ou

Avg(I1,I2)

- Extraire une composante de la première image :

* Rouge :

I1*#010000 ou bien I1 and #FF0000

* Vert :

I1*#000100 ou bien I1 and #00FF00

* Bleu :

I1*#000001 ou bien I1 and #0000FF

- Somme de la composante rouge de l'image 1 avec la composante verte de l'image 2 et la composante bleue de l'image 3

I1*#010000+I2*#000100+I3*#000001 ou bien (I1 and #FF0000) + (I2 and #00FF00) + (I3 and #0000FF)

- Doubler l'intensité lumineuse de l'image 1

I1*2

- Faire le carré de chacune des composantes de l'image

I1^2

- Faire la différence de 2 images :

* Obtenir une image binaire avec des points blanc où les pixels sont différents et noir sinon (ma été utile pour vérifier mon algo du jpeg sans pertes)

If(I1=I2,0,255) ou bien If(I1<>I2,255,0)

* Obtenir la différence réélle avec la couleur résultante

Abs(I1-I2)

Remarque : Les nombre décimaux ne sont pas disponibles mais il est possible de contourner le problème en utilisant des fractions :

- Multiplier par 1,5 l'intensité lumineuse de l'image 1

(I1*3)/2

Remarque : Les parenthèses ne sont pas obligatoires ici

- Faire un dégradé de gris horizontal adapté à l'image :

X(I1)*255/W(I1)

ou dans l'autre sens :

255-(X(I1)*255/W(I1)) ou (W(I1)-X(I1))*255/W(I1)

- Faire un dégradé de gris vertical adapté à l'image :

Y(I1)*255/H(I1)

ou dans l'autre sens :

255-(Y(I1)*255/H(I1)) ou (H(I1)-Y(I1))*255/H(I1)

- Faire le tutorial du fondu paysage / portrait :

Cette formule suffit :

AlphaBlend(I1,I2,X(I1),W(I1))

avec I1 le portrait et I2 le paysage!

Exemples complets avec variables, fonctions, commentaires... :
==============================================================

R:Max(W(I1)/4,H(I1)/4); //Rayon central
C:Root((X(I1)-W(I1)/2)^2+(Y(I1)-H(I1)/2)^2); // Cercle en dégradé
C:If(C<R,0,C-R); // Mettre en noir la partie centrale
M:Max(W(I1),H(I1))/2-R; // Maximum pour inverser le masque
IC:M-C; // Inversion du masque
(#0080C0*C+I1*IC)/M // Alpha blending avec une couleur

I1 est une image par exemple la panthere utilisée dans le tutoriel Texte et image du site officiel.

Assemmblage artistique entre 2 images :
=======================================

F:64; // Taille de la zone commune
H:Max(H(I1),H(I2)); // Hauteur maximale des 2 images
S1:BStretch(I1,W(I1)*H/H(I1),H); // Adaptation de la hauteur pour l'image 1
S2:BStretch(I2,W(I2)*H/H(I2),H); // Adaptation de la hauteur pour l'image 2
W:W(S1)+W(S2)-F; // Taille de l'image totale
T1:Tile(S1,W,H); // Augmentation de la zone de trevail de l'image 1
T2:Scroll(Tile(S2,W,H),W(S1)-F,0); // Augmentation de la zone de trevail de l'image 2 et positionnement au bon endroit
If(X(T1)<W(S1)-F,T1, // Image 1 
If(X(T1)>W(S1),T2,   // Image 2
AlphaBlend(T1,T2,X(T1)-W(S1)+F,F))) // Fondu


Bonne utilisation !



