Dans cette section nous allons voir comment creer des taches répétitives , travailler avec des conditions , il y aura aussi de nouvelles commandes concernant la fenetre de sortie , l'enregistrement d'images et la creation de video à partir de liste d'images avec un programme exterieur à LUA.
Vous allez voir qu'un script n'est rien de plus que de rassembler les commandes que vous avez déja apprises ainsi que quelques une servant à gérer tout ca ;)
Le point clef de tout les languages de programmation , script etc , s'appelle la variable !!
Les variables servent à 'emmagazinner' vos nombres , textes , résultats de calculs , elle sont bonnes à tout !
par example dans votre petit script LUA vous evrivez :
a = 10
b = "c'est moi"
Cela veut dire quoi ??? , et bien simplement que l'on stock le nombre 10 dans la variable 'a' et "c'est moi" dans la variable 'b'.
Pratiquement tout les languages demandent de préciser le 'type' de variable avant de pouvoir y stocker quelque chose. Et bien LUA n'en a pas besoin , c'est bien pour les non programmeur qui se tirerai les cheuveux un à un avant de comprendre de quelle type de variables ils ont besoin , mais c'est dangereux parcequ'on peut mélanger tout est n'importe quoi ;)
Dans l'example précédent on à initialisé 2 variables en leur donnant des valeurs , mais aprés 1000 ou 10000 lignes de codes et ayant plein d'autre variables dans le script , comment savoir à quoi correspondait a et b ?? , à par rechercher ces 2 variables et les suivre le long du script pour voir ce qu'elles stockent et dans quel contexte ,cela pourrais etre difficile de s'y repérer.
Donc , ce que l'on va faire c'est de donner un VRAI nom aux variables , un nom qui puisse dire quelque chose de concret , parce que 'a' ou 'b' ne veut rien dire !!
example :
resultat_calculs = 100
mon_nom = "DarthMagnet"
Ceci est déja plus parlant , qu'en pensez vous :)
Par convention les variables commencent toujour par une lettre.
Maintenant que l'on sait comment stocker des chiffres et des lettres ( c'était pas une emmission TV ca ? ) , on va pouvoir se pencher un peu sur les mathématiques de base du language LUA
Il y à comme dans toute bonnes mathématiques qui se respectent les bon vieux + , - , * (miltiplier) , / (diviser)
Mais voila ! , tout les opérateurs arithmetique n'on pas la meme priorité.
Il y à ce qui s'appel la précédence , ceci spécifie ce qui sera calculé en premier .
Par example , si l'on veut additionner 'a' avec 'b' et multiplier le résultat par 'c' il faudra faire
a = 10
b = 20
c = 30
d = (a + b) * c
print("resultat de (a+b)*c = ",d)
et non faire
a = 10
b = 20
c = 30
d = a + b * c
print("resultat de a+b*c = ",d)
La précédence veut que la multiplication soit de plus haute priorité que l'addition donc dans le 2eme example le calcul s'effectuerait de cette maniere : b * c et ensuite on additionne 'a' à ce résultat.
Par contre quand l'on separe les différentes étapes du calcul par des parenthéses , tout rentre dans l'ordre , vu que ce qui est entre parenthéses est calculé en premier et ensuite seulement les autres opérateurs entrent en ligne de compte.
Voici la liste des prioritées des opérateurs du language LUA en commencant par la prioritée la plus basse:
or
and
< > <= >= ~= ==
..
+ -
* / %
not # - (unary)
^
Ces opérateurs sont utiles pour les maths , mais comment faire pour savoir si une variable contient quelque chose d'égal , de différent , de plus grand , plus petit qu'une autre variable ?
Pour cela il existe les Opérateurs relationnels logique .... <-- ca fait mal au crane des mots pareil !!
Mais vous allez voir qu'en fait c'est trés simple ;)
De plus , ces opérateurs ne peuvent que donner deux types de résultats !! ... Vrais ou Faux
En Anglais cela donne True pour vrai , False ou Nil pour Faux
voici la liste de ces opérateurs :
== égal (2x le signe égal)
~= différent
< inférieur
> supérieur
<= inferieur ou égal
>= supérieur ou égal
Quelques examples pour vous montrer de quoi il s'agit.
petit_nombre = 10
grand_nombre = 20
resultat = false
resultat = petit_nombre == grand_nombre
resultat retournera Nil ( faux )
resultat = petit_nombre ~= grand_nombre
resultat retournera true (vrai)
resultat = petit_nombre < grand_nombre
resultat retournera true (vrai)
resultat = petit_nombre > grand_nombre
resultat retournera Nil ( faux )
resultat = petit_nombre <= grand_nombre
resultat retournera true (vrai)
resultat = petit_nombre >= grand_nombre
resultat retournera Nil ( faux )
Comme vous pouvez le constater , rien de bien compliqué ....
Maintenant il reste le dernier type d'opérateurs utile pour nos scripts , ceux si sont les Opérateurs Logique , il n'y en à que trois :) .... qui sont AND (et) , OR (ou) et NOT (non) , les opérateurs logique considérent False et Nil comme faux et tout les autres résultats comme vrai , comme vous le voyez ca s'annonce bien ;)
Examples repris de la doc LUA
10 or 20 --> 10
10 or error() --> 10
nil or "a" --> "a"
nil and 10 --> nil
false and error() --> false
false and nil --> false
false or nil --> nil
10 and 20 --> 20
Les opérateurs logiques fonctionnent aux niveau binaire , c'est a dire qu'il comparent bit à bit chaque élément à traiter.
Il devient compliqué de savoir ce que donnerais 25116 and 36547 ;)
C'est pour cela qu'on les utilise en général en plus des opérateurs relationnel dans les fonctions conditionnelles que l'on verra plus loin.
Maintenant qu'on as vu tout le bla bla nécessaire pour les variable et opérateurs , désolé , mais fallais passer par la !!
On va voir les fonctions conditionnelles et les boucles , la encore , vous verrez que pas à pas c'est trés simple ;)
Comme tout le monde le sais , une boucle est quelque chose qui pars d'un endroit pour se rejoindre au meme endroit :)
Et à chaque fois qu'on revient à l'endrois d'ou l'on est partie , on compte + 1 , pour savoir combien de fois l'on est passé par la.
Et bien , en programmation il y à plusieur facon de s'y prendre
1ere facon , certainement la plus connu , c'est un compteur qui s'incremente et execute des taches tant que ce compteur n'a pas atteint la valeur maximum fixé.
Ceci s'appel la boucle FOR
Example :
On veut incrementer un compteur 10 fois et rajouter le total du compteur à une variable , à la fin des 10 incrémentations on affiche le résultat.
Sans les boucles voila le tye de programme possible
-- **** On crée et initialise nos deux variables ****
compteur = 0
resultat = 0
-- **** on commence à compter ****
-- on incremente la variable compteur
compteur = compteur + 1
-- on rajoute la valeure actuelle de compteur à la variable resultat
resultat = resultat + compteur
-- ecrire encore 9 fois ce qui se trouve ci dessus !!
Cela donnerais des programmes de quelques kilometres de long si l'on devais faire 1000 ou 1 million d'incrémentations.
Et voila , maintenant on va voir comment une boucle fait tout ca en quatre lignes de programmation ;)
resultat = 0
for compteur = 1,10,1 do
resultat = resultat + compteur
end
print("Résultat = ",resultat)
J'ai pas menti , y'a vraiment quatre lignes :) ... ops ... 5 avec l'affichage du résultat :)
J'explique la fonction ... for compteur = 1,10,1 do veut dire le comptage commence à 1 s'arrete à 10 et est incrémenté de 1 à chaque fois . Si vous regardez la valeur de compteur à la sortie de la boucle vous verrez que celui ci vaut en fait 11.Au passage à l'instruction for le compteur est incrémenté , et vu qu'il à dépassé la valeur limite de 10 la boucle s'interrompt et va executer l'instruction suivant le end.
Tout ce qui se trouve entre for et end sera executé 10 fois , vous verez que cela peut donner des choses pas mal dans FEMM ;)
Pour example créer un objet quelconque assigné au groupe 1 et ecrivez puis lancer ceci dans la console LUA
compteur = 0
for compteur = 0,3,0.1 do
mi_clearselected()
mi_selectgroup(1)
mi_movetranslate(0.1,0)
end
Vous n'aurez certainement pas le temp de voir ce qui se passe , mais votre objet va translater vers la droite à chaque fois de 0.1 unitée et cela 31 fois. Si nous avion débuté la boucle avec comme valeur 0.1 celle ci se serait éxécuté 30 fois
N'ecrivez surtout pas FOR , DO ou END en majuscule !! , toutes les commandes LUA s'ecrivent en MINUSCULES !
Autre type de boucle cette fois ci ,on va dire que TANT QUE la variable compteur n'a pas atteind la valeur 10 on continu d'executer le code aprés la fonction.
Ceci est l'instruction WHILE
un example concret :
resultat = 0
compteur = 0
while compteur <= 10 do
compteur = compteur + 1
resultat = resultat + compteur
end
print("resultat = ", resultat)
Ici notre compteur ne s'incremente pas tout seul comme dans la boucle FOR.
Donc si l'on oubli de l'incrémenter , sa valeur sera toujours plus petite que 10 et la boucle sera sans fin.
Maintenant voyons le dernier type de boucle.
Il s'agit de REPETER les instructions TANT QUE le compteur n'a pas atteind la valeur de 10
resultat = 0
compteur = 0
repeat
compteur = compteur + 1
resultat = resultat + compteur
until compteur == 10
print("resultat = ", resultat)
La difference entre les boucles , FOR , WHILE et REPEAT et que la boucle REPEAT execute toujours au moin une fois le code qui se trouve avant UNTIL , vu que la condition disant qu'il faille continuer se trouve à la fin du bloc d'instructions.
Personnellement il est trés rare que j'utilise repeat / until , mais autant que vous sachiez que cela existe.
Autre chose trés importante en programmation , ... les CONDITIONS.
Imaginez que SI une valeur vaut 10 ALORS on déplace l'objet du groupe1 50 fois de 0.1 unité vers la gauche SINON
on déplace l'objet du groupe1 de 5 unitées vers la droite , comment faire ceci ...
Comme toujours , il existe des instructiions pour faire cela et celles ci sont IF.... THEN .... ELSE .... END.
Pour l'example de ci dessus il faudrai faire un programme du genre.
valeur = 10
if valeur == 10 then
for a = 1,50,1 do
mi_clearselected()
mi_selectgroup(1)
mi_movetranslate(-0.1,0)
end
else
for a = 1,5,1 do
mi_clearselected()
mi_selectgroup(1)
mi_movetranslate(0.1,0)
end
end
Notre valeur étant égale à 10 notre objet va se diriger vers la gauche.
Maintenant changez valeur et vous le verrez se deplacer vers la gauche à chaque fois que valeur sera differente de 10.
Je vous encourage à modifier ces petits examples afin de bien comprendre comment tout fonctionne. Pour vous entrainer pourquoi ne pas ecrire un programme dans le meme style pour que l'objet monte si valeur vaut 11 ou descendre quand cette valeur vaut 20 :)
Dans le cours précédent nous avion vu qu'il était possible de convertir les nombres en texte et les textes en nombre , ajouter un texte à un autre etc , je vais ici expliquer comment faire ,car cela est utile si vous voulez faire un script qui vous demande une valeur à entrer.
Nous allon donc commencer par 'coller' des chaine de caractéres (texte) ensemble , pour ce faire il y la ce qu'on appelle la concatenation ... et oui ... encore un mot pas possible à retenir ;)
Dans LUA ceci est symbolisé par ..
donc si l'on fait :
tout_le_texte = "texte1".."texte2".."texte3"
tout_le_texte contiendra texte1texte2texte3
Mais bien sur il serait plus interressant d'utiliser des variables .... comme ceci
texte1 = "je suis le texte 1"
texte2 = "Je suis le texte 2"
texte3 = "Je suis le texte3"
Et pour faire mieu et que tout ne sois pas collée directement au texte précédent on peut rajouter des espaces quand l'on transfére le résultat dans tout_le_texte
tout_le_texte = (texte1.." "..texte2.." "..texte3)
voyez le résultat dans l'image ci dessous ...
Autre chose intérréssante , c'est la possibilité de convertir des nombres en texte avec la commande tostring(nombre).
Cela va nous permettre de coller des textes et nombres ensemble en vu de l'affichage d'un résultat ou bien pour créer un nom de fichier ou l'on pourra incrémenter un compteur pour par example sauvegarder des images numéroté et ainsi pouvoir les utiliser pour créer des videos avec un programme externe à FEMM
Voila comment cela fonctionne.
nombre = 10
texte = "Le nombre vaut actuellement "
tout_le_texte = texte..tostring(nombre)
print(tout_le_texte)
Les bon eleves que vous-etes on certainement tilté en se disant qu'on aurai pu simplifier en faisant comme ceci:
print(texte,nombre)
C'est vrai , mais si vous voulez utiliser le résultat pour creer un fichier , seul une chaine de caracteres sera accepté :)
Donc , il n'y à aucune restriction à l'utilisation pour ce qui est de l'affichage de résultat ou tout autres choses dont vous avez besoin , mais dés qu'il faudra créer un texte pur et dur , cela sera la méthode employée.
Voyont maintenant comment faire le contraire :) ... On va de ce pas convertir un texte en nombre avec la commande qui s'appelle tonumber(texte)
cela peut etre utile quand votre script vous demande une valeur à calculer.
On va imaginer que le script demande de combien d'unité l'on veut décaler l'objet du groupe 1 en X et ensuite il pose la meme question pour le décalage en Y , voici le petit script utilisé.
texte1 = prompt("de combien doit-on décaler en X ?")
texte2 = prompt("de combien doit-on décaler en Y ?")
decalx = tonumber(texte1)
decaly = tonumber(texte2)
mi_clearselected()
mi_selectgroup(1)
mi_movetranslate(decalx,decaly)
print("nous avons décalé l'objet du groupe 1")
print("de ",texte1,"unité en X")
print("de ",texte2,"unité en Y")
Il existe une methode plus compacte pour ecrire ceci.
texte1 = prompt("de combien doit-on décaler en X ?")
texte2 = prompt("de combien doit-on décaler en Y ?")
decalx = tonumber(texte1)
decaly = tonumber(texte2)
On peut faire comme ceci ...
decalx = tonumber(prompt("de combien doit-on décaler en X ?"))
decaly = tonumber(prompt("de combien doit-on décaler en Y ?"))
On élimine en meme temp les variables texte1 et texte2.
Il faudra donc aussi modifier la facon d'afficher les résultats comme ceci :
print("nous avons décalé l'objet du groupe 1")
print("de ",decalx,"unité en X")
print("de ",decaly,"unité en Y")
Comme on peut le constater , il y a beaucoup de manieres différentes pour avoir le meme résultat , donc à vous de choisir la maniére qui vous va le mieu :)
Nous allons maintenant voir quelques commandes utiles concernant la fenétre ou l'on vois les résultats des calculs dans FEMM.
Ces commandes commencent toutes par mo_ , ce qui veut dire Magnetic Output , donc ceci est la fenétre de sortie.
On à vu précédement que mi_analyse() lance les calculs et que mi_loadsolution() les récupére et passe dans la fenetre de sortie.
Nous devons maintenant afficher la denstité magnétique avec ses belles couleurs afin de se rendre compte de ce qui se passe dans notre montage.
La commande utilisée pour faire ceci est mo_showdensityplot(legende,niveau de gris,max B field ,min B field,type)
Voyon à quoi tout ceci correspond:
legende à 1 affiche la fenetre des legendes des couleurs avec les valeures magnetiques par niveau de couleurs , si lengende est à 0 cette fenetre n'est pas affichée.
niveau de gris et le paramétre a modifier si vous voulez voir le champ magnétique en couleur , si ce paramétre est à 0 , alors les couleurs seront affiché , sinon , si le paramétre est à 1 ce sera en niveau de gris.
max B field est la valeure à entrer pour donner la valeur maximum du B field calculé , personnellement je lance une fois le calcul à la main et je regarde ce qu'il y à d'écrit pour ces paramétre quand l'on demande l'affichage de la densité magnétique en couleur ... voici un example ...
Pour ce montage les valeures à entrer pour max et min B field serait donc
pour max B field : 0.9 (j'arondi à la valeure juste au dessus)
pour min B field : 3.7 e-005 = 0.000037 , et c'est la valeur que j'utilise.
Pour le parametre type y'a pas le choix , c'est "mag" pour dire que l'on veut calculer quelque chose de magnétique.
La commande pour ce montage serait donc:
mo_showdensityplot(0,0,0.9,0.000037,"mag")
voyons ce que cela donne en entrant ceci :
mi_analyze() -- faire les calculs
mi_loadsolution() -- charger le resultat d'analyse
mo_showdensityplot(0,0,0.9,0.000037,"mag") -- afficher la densité magnetique en couleur
Ce qui me dérange un peu ce sont tous ces points .... on va les faire disparaitre de la fenetre de sortie avec la commande
mo_hidepoints()
si vous voulez les faire réapparaitre , utilisez mo_showpoints() ....
Maintenant on va enregistrer notre image , dans l'index des commandes vous avez vu comment enregistrer un fichier FEMM , maintenant ce qui nous interresse c'est d'enregistrer l'image , c'est pareil sauf que le nom de la commande change.
On va utiliser mo_savebitmap("nom de fichier.bmp")
LUA ne rajoute pas automatiquement l'extension BMP donc ne l'oubliez pas ;)
Si dans votre script vous avez ceci:
nom_du_fichier = "image"
il faudra enregistrer comme ceci mo_savebitmap(nom_du_fichier..'.bmp")
vous auriez tout aussi bien avoir ceci dans votre script :
nom_du_fichier = "image.bmp"
mo_savebitmap(nom_du_fichier)
c'est pareil à par un point , c'est que si vous avez à enregistrer une séquence d'images afin d'en faire une video , vous n'auriez pas pu rajouter le numéro de l'image à la fin du nom de celle ci ....
Je vous parle depuis quelques temp de sequence d'images , de video etc .... maintenant je vais vous expliquer avec un example concret comment tout cela fonctionne et l'on pourra dire que vous serez apte à comprendre comment LUA fonctionne.
Nous allons pour ceci créer pas a pas un projet complet.
Commencez par creer ceci ....
Maintenant on va definir les contours jusqu'on FEMM va calculer et assigner le contour au groupe 0
Je reduit ma fenetre FEMM au maximum pour que cela ne prennent pas trop de temp à télécharger ici ...
Nous avons maintenant nos 3 objets ainsi que le contours , il ne nous reste plus qu'a copier / tourner les objets avec les parametre suivants
L'objet du groupe 1 sera tourné de 45° à chaque fois
L'objet du groupe 2 sera tourné de 30° à chaque fois
L'objet du groupe 3 sera tourné de 60° à chaque fois
Les rotations s'effectueron à partir de la coordonnée 0,0
Je vous laisse faire , vous l'avez appris ...
maintenant fermez votre console LUA , elle ne sera plus utile pour le reste du projet.
Ouvrez un nouveau document texte à l'aide de votre bon vieu notepad.
C'est maintenant que l'on commence vraiment à ecrire un script
Mais avant cela nous allons définir ce que ces objets sont censé faire
nous allons donc dire que le groupe 1 va tourner dans le sens trigonométrique (sens contraire des aiguilles d'une montre) par pas de 1°
Le groupe 2 se contentera de rester sur place.
Le groupe 3 va tourner dans le sens anti-trigonometrique (sens des aiguilles d'une montre) par pas de 1°
Les deux groupe devant tourner le ferons sur 360°
Aprés chaque pas de rotation de 1° , une analyse devra etre éffectué , la fenétre de sortie devra montrer le résultat en couleur sans les points et l'image de cette analyse devra etre enregistrée avec le numéro de l'angle actuel dans le style
image000.bmp à image359.bmp
Ce qu'il nous faudrais pour nous faciliter la vie c'est une nouvelle commande LUA , cette commande devrai pouvoir faire ceci :
Déselectionner tout les objets
Selectionner les objets du groupe voulu
Faire tourner les objets du groupe selectionnée autour d'un point X,Y de référence.
En programmation ceci s'appel une FONCTION
Pour creer une fonction qui puisse ne tourner qu'un seul groupe d'objet et a un angle voulu , il nous faut pouvoir dire à la fonction ce que l'on veut faire.
Pour cela , la fonction aura des Paramétres d'execution.
Pour notre projet l'appel de la nouvelle fonction serait dans ce style la :
tourner_objet(x,y,groupe,degree)
Le probleme c'est que cette fonction n'existe pas :(
Alors on va la créer ;) .... et vous allez voir que c'est trés simple
dans votre nouveau fichier texte vous pouvez entrez ceci :
function tourner_objet(referencex,referencey,groupe,angle)
mi_clearselected()
mi_selectgroup(groupe)
mi_moverotate(referencex,referencey,angle)
end
J'explique ce qui se passe quand cette fonction est appelé .
Admetton que vous faite ceci : tourner_objet(0,0,1,10)
A l'execution , cette commande fera tourner l'objet du groupe 1 autour du point de reference 0,0 et cela sur 10°
Maintenant que nous avons une nouvelle commande , on peut se penchez sur le script proprement dis
à la suite de la fonction nous alons créer une variable pour compter les degrées , vu qu'il faut tourner les objet du
groupe1 et ceux du groupe 3 sur 360°
donc on crée :
compter_degree = 0
Nous allon aussi ajouter une variable pour le nom de notre image de sortie
fichier_image = "image"
On va aussi créer une variable qui contiendra le numéro de l'angle actuelle en chaine de caracteres
numero_image = "0"
Maintenant nous allons devoir faire tourner nos 2 groupes d'objets par pas de 1° jusqu'a ce que ce compteur atteigne la valeur 360
Il y a plusieures methodes pour faire cela , FOR , WHILE , REPEAT ... personnellement je vais utiliser WHILE
Ecrivons donc nos quelques lignes de code pouvant faire tout ce travail ....
while (compter_degree < 360) do
tourner_objet(0,0,1,1)
tourner_objet(0,0,3,-1)
mi_analyze()
mi_loadsolution()
mo_showdensityplot(0,0,0.82,0.000018,"mag")
mo_hidepoints()
mo_resize(608,608)
mo_zoomnatural()
numero_image= tostring (compter_degree)
if (compter_degree >= 100) then fichier_image = "image"..numero_image..".bmp" end
if (compter_degree < 100) then fichier_image = "image0"..numero_image..".bmp" end
if (compter_degree < 10) then fichier_image = "image00"..numero_image..".bmp" end
mo_savebitmap(fichier_image)
compter_degree = compter_degree + 1
end
Pour le moment ,ignorez les commandes mo_resize(x,y) et mo_zoomnatural()
Voila notre premier script terminé , sauvegarder le et appelez le dans FEMM à partir du menu 'File' -> Open Lua Script
Le script va commencer à calculer directement , il y aura 360 calculs à éffectuer , donc soyez patient , cela risque de prendre un certain temp ;)
On va s'atteler maintenant à faire une vidéo à partir de toutes ces images.
La aussi il faut connaitre certaine choses
Déja il va falloir trouver un programme qui puisse convertir une liste d'images en vidéo
Pour ma pars j'utilise :Easy Video Converter , mais tout autre programme ayant la possibilité de contertir une liste d'images en video fera l'affaire.
Ce qu'il faut savoir quand on veut creer une video c'est que la largeur et hauteur de vos images doivent etre un multiple de 16 , si cela n'est pas le cas votre compresseur video peut vous sortir un message d'erreur , il y en as meme comme le DivX par example qui n'accepte pas toutes les variantes de taille en Largeur / Hauteur , donc , j'utilise le format Xvid qui est bien plus souple de ce point de vu , et avec FEMM il est rare d'avoir un montage de la forme et taille accepté par DivX ;)
C'est ici que la commande mo_resize(largeur,hauteur) entre en scéne , vu que l'on sais par avance quelle 'forme' aura l'image de sortie , on sais à peut prés les valeures à donner pour les parametres largeur,hauteur.
Notre montage actuel est pratiquement carré , et vu que je veut bien voir ce qui se passe je ne vais pas créer d'image trop petite , donc j'ai opté pour 608 x 608 , ce qui laisse bien voir notre champ magnétique , et 608 est biensur un multiple de 16 ;)
Maintenant pour que notre montage soit bien dans complet dans notre fenetre de sortie réajusté à la taille voulu il faut utiliser la commande mo_zoomnatural() , cette commande va tout faire tout seul :) , elle va rezoomer sur le montage et faire en sorte que tout soit visible.
Nous sommes arrivé à la fin de ce cours , j'espére que celui-ci vous aura aidé et que maintenant la simulation magnétique par script programmé ne vous fait plus peur ;)
Et n'oubliez pas qu'il reste encore d'autres commandes , tout ceci se trouve dans la documentation de FEMM ..
Cours Script LUA par DarthMagnet ...