Apprendre C++ cours

DØclaration : classe objet;

signi cation

Limites

int a;

nombre entier

-2147483648

2147483647

double d;

nombre rØel double prØcision

±10±308

10^?9 pr?s

char e;

caract?re

bool v;

boolØen : vrai (true) ou faux (false)

char * t;

cha ne de caract?res

Signi cation

symbole

supØrieur

> 

infØrieur

< 

supØrieur ou Øgal

>=

infØrieur ou Øgal

<=

Øgal

==

di Ørent de

!=

Signi cation

symbole

et

&&

ou

||

non

!

Classe

char

short int

int

long

float

double

Taille (en byte)

1

2

4

4

4

8

#include<iostream> using namespace std; #include <bitset> int main() { int i=17;

cout<<"La variable int i="<<i<<" est de taille "<<sizeof(i)<<" bytes."<<endl; unsigned char *p=(unsigned char*)&i; // Le pointeur p est l’adresse

memoire de i cout<<"Contenu des bytes, en ecriture base 10:"<<endl; for(int i=0; i<sizeof(i);i++)

cout<<" "<<(int)p[i];

cout<<endl<<"Contenu des bytes, en ecriture base 2:"<<endl; for(int i=0; i<sizeof(i);i++) cout<<" "<<bitset<8>(p[i]);

cout<<endl; }

A    che :

La variable int i=17 est de taille 4 bytes.

Contenu des bytes, en ecriture base 10:

17 0 0 0

Contenu des bytes, en ecriture base 2:

00010001 00000000 00000000 00000000

11.2          Fichiers en format texte

Dans les le ons prØcØdentes, nous avons vu comment Øcrire des donnØes numØriques dans un chier. Ces donnØes Øtaient Øcrites sous forme de chi res (ex : 17) et sont lisibles depuis un Øditeur. On dit qu’il s’agit d’une Øcriture en format texte ou format ASCII; car un objet numØrique est reprØsentØ en base dix par un ou plusieurs chi res dans le chier.

Lorsque l’on Øcrit dans un chier en format texte (par la commande fichier<<i<<endl; ) l’ordinateur convertit le nombre en base dix et Øcrit la suite des chi res, ce qui donne 17. (Il faut savoir que chaque caract?re est codØ par un octet en mØmoire, selon le codage ASCII).

L’avantage du format texte est que l’on peut visualiser le contenu du chier l’aide d’un Øditeur comme emacs.

Rappels sur le code ASCII :

cout <<(int)’A’ << endl; // --affiche 65 qui est le code ASCII de

A cout <<(char)(65) << endl; //--affiche A qui a pour code ASCII: 65

11.3          Fichiers en format binaire

11.3.0.1        Exemple

Le programme suivant montre comment Øcrire et lire en format binaire, et comment se positionner dans un chier.

#include <stdlib> #include <iostream> using namespace std; #include <fstream> #include <iomanip>

int main() { double x=3.14; int i=17;

int nx=sizeof(double); //nombre de byte occupØs par un objet de

classe double int ni=sizeof(int); //nombre de byte occupØs par un objet de classe

int cout<<"nx= "<<nx<<" ni= "<<ni<<endl; //===============================

ofstream sortie( " ",ofstream::binary); //ouverture d un

fichier en ecriture -sortie.write(&x, nx); //--- ecriture de x --sortie.write(&i, ni); //--- ecriture de i --sortie.close(); //- fermeture du fichier --

//===============================

ifstream entree( " ", ifstream::binary); //-- ouverture

d un fichier en lecture (&x, nx); //--- lecture de x (&i, ni); //--- lecture de i --cout<<" x= "<<x<<" i= "<<i<<endl;

entree.seekg(nx); // on se positionne apr?s nx octets en partant

du dØbut, soit apr?s la valeur de x (&i, ni); //--- lecture de i --cout<<" i= "<<i<<endl;

int pos=entree.tellg(); // donne la position du curseur dans le

fichier (en byte) cout<<"la position du curseur est maintenant: "<<pos<<endl; }

11.3.0.2        Remarques

Pour se positionner en lecture, il faut utiliser la fonction seekg. Pour se positionner en Øcriture, il faut utiliser la fonction seekp. Le premier argument de ces fonctions indique le dØplacement relatif du pointeur (en byte). Le deuxi?me argument (facultatif) indique l’origine du dØplacement. Ce peut-Œtre :

le dØbut du     chier : ios::beg la position actuelle du curseur : ios::cur

                la    n du      chier ios::end

exemple : entree.seekg(nx,ios::beg); // on se positionne apr?s nx octets en partant du dØbut

Quelques commandes utiles

12.0.1          La commande system

La commande system() permet de lancer d’autres commandes ou programmes sur l’ordinateur. Par exemple pour lancer la commande ls qui a che la liste des chiers :

#include <iostream> // pour cout using namespace std;

#include <stdlib.h> // pour system

//----Fonction principale ---------------int main()

{ system("ls"); // execute la commande ls. (affiche les fichiers)

}

96

Chapitre 13

Classes (suite)

          Cette Section fait suite       la Section 7.

13.1          SurdØ nitions d’opØrateurs

13.1.1           Exemple d’opØrateur binaire

Pour e ectuer le produit scalaire entre deux vecteurs, plut t que d’utiliser la fonction Produit ci dessus, on aimerait utiliser la syntaxe plus agrØable : d=v*w; cela est possible en redØ nissant l’opØrateur * de la fa on suivante.

        Code      rajouter dans le code des fonctions membres :

double operator*(Vect v2)

{ double p=0; p=x*v2.x+y*v2.y+z*v2.z; return p;

}

Utilisation dans le programme principal :

int main()

{ double d; Vect v(1,2,3); Vect w(2,3,4);

d=v*w;

                                   cout << d=         << d << endl;

}

97

13.1.2         Commentaire

La syntaxe de l’opØration * est semblable celle de la fonction membre Produit. Comme pour Produit, Il est important de remarquer Vect v2 est un param?tre de l’opØration *. Lorsque l’on Øcrit d=v*w, l’opØration * est appelØe pour l’objet v qui se trouve gauche de * (et non w); l’appel de cette opØration, le vecteur v2 prend la valeur de w qui se trouve droite de *.

On dit que * est un opØrateur binaire car lors de l’appel d=v*w il y a deux entrØes pour *. Il y a sa gauche l’objet de la classe, et sa droite un autre objet ( priori quelconque, ici Vect v2).

(),[ ], -> , *,/,%,+,-, << ,>>,<,<=,>,>=,==,!=,&,^, ||,&&,|,=, +=,-=,*=,/=,%=,&=,^=,|=, <<=,>>=,et la virgule ,.

Exercice 13.1.1. (*)

1.    Ecrivez le code pour e ectuer la somme (termes termes) et la di Ørence de deux vecteurs par la syntaxe : w=u+v; w=u-v; et testez.

2.    Ecrivez le code pour e ectuer le produit et la division externe d’un rØel a avec un vecteur v (produit de chaque ØlØment) par la syntaxe w=v*a; ou w=v/a; et testez.

3.    On aimerait accØder aux variables membres v.x,v.y,v.z respectivement, par la syntaxe v[1],v[2],v[3]. Cela est possible en dØ nissant l’opØrateur [ ] avec la dØclaration double & operator [ ](int i); A l’utilisation, on Øcrit par exemple d=v[1];. Ecrivez le code de cet opØrateur et testez.

Rem : le signe & permet d’Øcrire aussi une a ectation comme v[1]=3;. Cela sera mieux expliquØ au paragraphe a ectations .

13.1.3            Exemple d’un opØrateur unaire

Comme en mathØmatiques, on aimerait donner un sens (?v) qui est l’opposØ du vecteur v. Pour cela il faut Øcrire :

        Code      rajouter dans le code des fonctions membres :

Vect operator-()

{ return (*this)*(-1);

}

Utilisation dans le programme principal :

int main() {

Vect v(1,2,3); Vect w; w=-v;

w.Affiche();

}

13.1.4         Commentaires

On dit que - est un opØrateur unaire car lors de l’appel w=-v car la seule entrØ de - est l’objet v de la classe qui se trouve droite. (il n’y a pas d’entrØe gauche). Les symb les possibles pour un opØrateur unaire sont :

+,-,++,--,!,~,*,&,new,new[],delete,(cast)

(*this) dans la fonction membre signi e l’objet en cours. Ici il s’agit du vecteur v. Remarquez la fa on Øconomique de calculer le rØsultat : on utilise la multiplication externe dØj programmØe.

Exercice 13.1.2.

Simpli ez le code de l’opØrateur binaire w=v/a dØj Øcrit en utilisant l’opØrateur binaire * .

13.2        Fonctions amies

13.2.1        Exemple

La syntaxe que permet les fonctions membres ci-dessus a une petite limitation. Dans la classe Vect, on aimerait par exemple dØ nir le produit externe * d’un double a avec un

Vect v, et Øcrire : w=a*v;

Mais d’apr?s la disposition des objets, il faudrait que * soit un opØrateur binaire de l’objet a qui se trouve gauche . On peut cependant associer cette opØration la classe Vect de l’objet v en Øcrivant :

        Code      rajouter dans le code des fonctions membres :

friend Vect operator*(double a,Vect v2)

{ return (v2*a);

}

Utilisation dans le programme principal :

int main()

{ double d(2);

Vect v(1,2,3); Vect w; w=d*v;

}

13.2.2         Commentaire

Le prØ xe friend signi e que cet opØrateur n’est pas exactement une fonction membre de la classe Vect, mais pas non plus indØpendante puisque elle est dØclarØe avec la classe. Remarquez l’ommission du prØ xe de rattachement Vect:: .

Les param?tres de l’opØration * dans la dØclaration sont (double a,Vect v2).Ils se trouvent de part et d’autre de * lors de l’utilisation : w=a*v;

Comme en mathØmatiques, on a dØ nit a*v=v*a. Mais on pourrait Øcrire ce que l’on veut et ne pas respecter la commutativitØ. la dØclaration double d(2) est Øquivalente double d=2. (La signi cation est que le constructeur double(int) est appelØ.)

13.2.3            Exemple de cout <<

        Code      rajouter dans le code des fonctions membres :

friend ostream & operator <<(ostream & sortie, Vect v2)

{ sortie <<"Vecteur: "<<v2.x <<"|"<<v2.y <<"|"<<v2.z

<<"|"; return sortie;

}

Utilisation dans le programme principal :

int main() {

Vect v(1,2,3); cout <<v <<endl;

}

Exercice 13.2.1. (*)

Ecrivez le code nØcessaire a n de pouvoir demander le contenu d’un vecteur l’utilisateur par la syntaxe cin >>v; L’utilisateur doit entrer les composantes la suite des questions Vect x=?,y=?,z=?. La syntaxe est cette fois-ci : istream & operator >>(istream & entree,Vect & v2);

Le symbole & s’appelle passage par rØfØrences, et est nØcessaire puisque le vecteur v est modi Ø la sortie de la fonction.

13.3          Vecteurs de taille variable

On va amØliorer la classe de vecteurs de R³ prØcØdente, en permettant d’avoir des vecteurs de R^N avec N quelconque, au choix de l’utilisateur.

Important : avant de commencer, nous conseillons vivement de (re)lire le paragraphe sur les pointeurs.

Il appara t que les variables membres de la nouvelle classe, doivent Œtre :

        (Code      Øcrire dans la dØclaration de la classe :)

//---- variables membres int N; //taille double *element; //pointeur

Important : la valeur de N nous renseigne tout moment sur la taille de l’espace mØmoire rØservØ.

Cette modi cation nous obligera rØØcrire les fonctions membres de la classe Vect, mais aussi d’introduire deux nouvelles fonctions membres : le constructeur par recopie, et l’opØrateur d’a ectation =.

Exercice 13.3.1. CrØer une nouvelle classe de vecteurs, qui contient les variables membres ci-dessus, avec les fonctions membres suivantes :

Une fonction membre Libere() qui lib?re l’espace mØmoire de taille N.

(1) Lib?re l’emplacement mØmoire dØj         existante (si N>0) (2) :RØserve l’emplacement mØmoire de taille Ni , (si Ni>0).

(3)    :met N=Ni.

(4)    met les composantes du vecteur zØro.

Un constructeur Vect(), qui met seulement N = 0, et ne rØserve pas de place

mØmoire. (il appelle la fonction : Init(0); )

Un constructeur Vect(int Ni), pour crØer un vecteur de taille Ni (il appelle la fonction : Init(Ni); ).

Un destructeur ~Vect() qui lib?re l’espace mØmoire. (il appelle la fonction Libere())

13.3.1           Constructeur par recopie

Dans un exercice prØcØdent, nous avons Øcrit une fonction membre double Produit (Vect v2). Lors de l’appel de cette fonction par la syntaxe v.Produit(w) dans le programme principal, un objet v2 est crØØ, et l’objet w est copiØ dedans. Mais il Øtait apparu qu’aucun Constructeur n’Øtait explicitement appelØ pour cette recopie. La raison est que le compilateur C++ a appelØ un constructeur de recopie par dØfaut, qu’il a crØØ lui-mŒme. Dans ce constructeur par dØfaut, il est e ectuØe une recopie simple des variables membres (il s’agissait de x,y,z).

Dans le cas actuel, une recopie simple des variables membres ne su t pas. A la crØation du nouvel objet Vect v2, il faut en e et rØserver l’emplacement mØmoire, et donc Øcrire nous mŒme le constructeur par recopie. Le code est le suivant :

        Code      rajouter dans le code des fonctions membres :

Vect (const Vect & v2)

{

// code        Øcrire (exercice) }

13.3.2            OpØrateur d’a ectation =

Dans la classe Vect de R³, si v,w sont deux vecteurs, et que l’on Øcrit l’opØration d’a ectation :

v=w;

On va Øcrire nous mŒme le code de l’opØrateur d’a ectation = Code   rajouter dans le code des fonctions membres :

Vect & operator=(const Vect & v2)

{

// code        Øcrire (exercice) }

Exercice 13.3.2.

1.    Ecrivez le code du constructeur par recopie et de l’opØrateur d’a ectation = ci dessus, et testez. (en a chant des messages).

2.    Reprenez les fonctions membres de la classe Vect de R³ prØcØdente, et Øcrivez les versions Vect de R^N correspondantes.

Concernant spØcialement l’opØrateur [ ], avec N ØlØments, on dØcide d’y accØder de la fa on suivante :

Vect v(N);

v[0],v[1], ,v[N-1],

Rem : Dans le code de l’opØrateur [ ](int i), il est bien de tester si l’indice i est dans l’intervalle autorisØ, et sinon d’a cher un message d’erreur (i.e. si i<0, ou i>N-1).

3.    Dans un deuxi?me temps, on aimerait que le premier indice i₁ soit quelconque (et pas forcØment i₁ = 0). Par exemple, que les trois composantes d’un vecteur de

R³soit v[2],v[3],v[4],i.e. i₁ = 2,N = 3;

PrØcisement, on voudrait qu’un vecteur soit caractØrisØ par sa taille N, et par son premier indice i₁, a n d’accØder aux ØlØments du vecteur par la commande v[i] avec.

Il faut donc rajouter i₁comme variable membre de la classe, et modi er les constructeurs et destructeurs, et fonctions membres si besoin est. A la n, on aura une classe de vecteur assez sophistiquØe, et prŒte l’emploi.

4.    (Long) Sur le mŒme mod?le que la classe vecteur, crØer une classe matrice, avec les opØrations usuelles.

Rem : on pourra dØ nir une matrice N*M comme Øtant un tableau de vecteurs, et prendre comme variables membres:

int N,M; // taille Vect * ligne;

Rem : attention aux fonctions Init() et Libere() !

Chapitre 14

Gestion de projets avec  chiers .h, Make le, Git et Doxygen

14.1          Projet avec plusieurs         chiers,       chier .h

Voici un projet informatique en C++, tr?s simple (et sans trop de sens) qui est fait de 3 chiers : un chier qui contient la fonction main() par laquelle commence le programme. un chier qui contient une classe Vect et une fonction f utilisØes dans la fonction main. un chier main.h qui contient les dØclarations de la classe Vect et de la fonction f. Le su xe .h signi e header (comme entŒtes ).

14.1.0.1           RØsultat du programme :

Norme de v=1

3*3=9

14.1.0.2          Code c++

//== f i c h i e r            main . cc =============

#include <iostream> using namespace std ;

#include          "main . h" int   main ()

104

{

Vect v ; v . x=1;

cout<<"Norme de v="<<v .Norme()<<endl ; cout<<"3*3="<<f(3)<<endl ;

}

Remarque 14.1.1. Au dØbut du chier , l’instruction #include "main.h" a pour e et d’inclure le contenu du chier main.h cet endroit. Il y a les dØclarations (mais pas le code) de la classe Vect et de la fonction f qui sont utilisØes dans la fonction main().

//== f i c h i e r             autres . cc =============

#include         "main . h"

#include <math .h>

//??? contenu du constructeur Vect : : Vect ()

{

x=0; y=0; z=0;

}

//?????contenu de   la         fonction Norme double          Vect : : Norme()

{ return           sqrt (x*x+y*y+z*z ); }

//??? code de la fonction f double f ( double x)

{

return x*x ;

}

Remarque 14.1.2. Le chier contient le code des fonctions membres de la classe Vect et le code de la fonction f(). Noter la syntaxe particuli?re Vect : :Norme() qui signi e fonction Norme de la classe Vect.

//== f i c h i e r           main . h =============

#i f ! defined (__MAIN_H) #define __MAIN_H

//?????? d ’ une          classe

class        Vect

{ public :

double x , y , z ;

double Norme ( ) ;

};

// ????? declaration d ’ une fonction double f ( double x );

#endif

Remarque 14.1.3. Le chier main.h contient les dØclarations (et non pas le code) de la classe Vect et de la fonction f(). Les lignes particuli?res :

#if!de ned(__MAIN_H)

#de ne __MAIN_H

#endif ne sont pas nØcessaires ici mais sont souvent utiles : ce sont des instructions du prØprocesseur c’est dire que au moment de la compilation, si le compilateur voit le code intermØdiaire la premi?re fois, il le consid?re (et met la variable __MAIN_H 1). Les fois suivantes, il ne consid?re par cette partie de code. L’intØrŒt de cela est que si le chier main.h se trouve rØpØtØ cause d’inclusions multiples (par exemple le chier A.cc inclut main.h et B.h, et le chier B.h inclut main.h), alors le code n’est Øcrit qu’une seule fois, ce qui Øvite une erreur de code dØj dØclarØ .

14.1.0.3           Commandes de compilation

g++ -c -o main.o g++ -c -o autres.o g++ main.o autres.o -o main

Remarque 14.1.4. Le premi?re ligne signi e on compile le chier c++ et on fabrique un chier en langage machine main.o . De mŒme pour la deuxi?mre ligne. La troisi?me ligne signi e partir des hciers main.o et autres.o on fabrique le chier exØcutable nal main .

14.2              Un programme Make le pour gØrer la compilation

Dans l’exemple de la section 14.1.0.3, si les chiers sont importants et si on e ectue une modi cation du code que dans le chier , on souhaiterait de pas refaire la commande de compilation g++ -c -o autres.o. Le programme Makefile permet de gØrer cela automatiquement (il regarde les dates de modi cation des chiers). Voici un tutoriel sur le Make le. Voici le

# ??? f i c h i e r Makefile main . o : main . cc main . h g++ ?c main . cc ?o main . o

autres . o : autres . cc main . h g++ ?c autres . cc ?o autres . o

f i n a l : main . o autres . o g++ main . o autres . o ?o main

Commande de compilation             on Øcrit :

make final

rØsultat :

g++ -c -o main.o g++ -c -o autres.o g++ main.o autres.o -o main

Commentaires :

Dans le chier Make le, les deux lignes main.o: main.h g++ -c -o main.o

signi ent que si on souhaite main.o , cela dØpend des chiers et main.h, et si un de ces derniers a ØtØ modi Ø il faut ØxØcuter la commande g++ -c -o main.o

la commande make nal signi e que l’on souhaite final. Cela a pour e et d’enclencher les commandes de compilation nØcessaires. Essayer par exemple de modi er seulement le chier et refaites make final. Le rØsultat est :

g++ -c -o main.o g++ main.o autres.o -o main

14.2.1               Un programme Make le plus pratique

Le programme suivant est totalement Øquivalent au prØcØdent mais il est plus pratique car on a placØ des instructions de compilation dans des variables (en lettres majuscules). Ainsi si vous rajoutez des librairies, il su t de la faire un seul endroit. De plus gr ce au symbols [email protected] et $* on Øvite des rØØcritures.

# ??? f i c h i e r         Makefile

# . . . .        l i b r a i r i e s

LIBR = ?lm

# . . .           instructions       de      compilation

CC =g++ ?std=c++11 OBJETS= main . o autres . o

main . o :       main . cc main . h

                             $(CC) ?c         $ *. cc ?o [email protected]

autres . o :           autres . cc main . h

                             $(CC) ?c         $ *. cc ?o [email protected]

f i n a l     :    main . o     autres . o

$(CC) $(OBJETS) ?o main $(LIBR)

lib :

                           ar     r main

clean :

rm *. o

Remarque 14.2.2.

Par exemple dans ce tutorial, on utilise souvent beaucoup de librairies et au total on Øcrira :

LIBR=$(shell root-config --libs) $(shell root-config --glibs) -lm -lpthread

CC =g++ -std=c++11 $(shell root-config --cflags) # compilateur

                  On a rajoutØ l’entrØe clean qui permet d’e acer tous les     chiers en langage machine

.o par la commande make clean

On a rajoutØ l’entrØe lib pour crØer une librairie.

14.2.2            Generation automatique du             chier make le?

Voir generation avec GNU

14.3             Gestion de versions d’un projet avec Git

Le logiciel permet de gØrer di Ørentes versions d’un projet. Il se souvient de l’historique. On lui indique une liste de chiers ( le dØpot ) et rØguli?rement on lui demande de faire une sauvegarde (par l’instruction commit)

14.3.0.1              Utilisation de Git sur son ordinateur

]La premiere fois :

Dans le rØpertoire de travail, taper git init

Cela initialise un rØpertoire .git/ Ecrire (en mettant votre nom et adresse) :

git config --global "Frederic Faure"

git config --global user.email Cela modi e le           chier ~/.gitconfig

A faire au cours du projet :

git status :montre l’Øtat des chiers par rapport au dØpot. git add ou git add ’*.cc’ ou git add * pour ajouter un (des) chier(s) au dØpot

git commit -m " rst commit" fait une sauvegarde des chiers du dØpot avec le titre indiquØ git log pour voir l’historique des opØrations git rm chier :enleve un chier du dØpot git mv le1 le2 : deplace ou change le chier.

                  git di       pour lire les di erences

                 Dans le       chier .gitignore il y a les extensions et repertoires        ignorer.

14.4 Collaboration et partage de projets sur internet avec GitHub

Si vous dØveloppez un projet avec des collaborateurs, vous pouvez dØposer (gratuitement) votre projet sur le site (par exemple).

Au dØpart il faut vous crØer un compte sur github qui va hØberger votre projet.

Si votre projet s’appelle projet, et votre compte s’appelle fdrfaure

Commandes :

git remote add projet Cela associe votre projet local au dØpot sur le site web git push -u projet master

Cela dØpose les derni?res modi cations de votre projet sur le site web git pull expanding_map master

Cela permet de rØcupØrer les derni?res modi cations (posØes par les collaborateurs) qui sont sur le site web. git clone repertoire_local Cela copie le dØpot du site web sur votre rØpertoire local. (a faire une premiere fois pour copier un projet)

14.5             Commenter et documenter un projet avec Doxygen

Nous expliquons l’utilisation de base de pour documenter automatiquement un projet en c++.

14.5.1               CrØation et consultation de la documentation

14.5.1.1             CrØation de la documentation html

Se placer dans le rØpertoire du projet.

Dans une console, lancer le programme doxywizard et con gurer les param?tres. On gØn?re la documentation par Run . Cela crØe des rØpertoires : html et latex.

14.5.1.2            consultation de la documentation

                 On lit le      chier

Pour la documentation pdf, dans le rØpertoire latex, executer la commande make. Cela gØn?re le chier

14.5.2             conventions pour Øcrire les commentaires

14.5.2.1          Page principale :

(voir mainpage) Ecrire :

/*! \mainpage Titre \section Nom_section texte

*/

CHAPITRE 14. GESTION DE PROJETS AVEC FICHIERS .H, MAKEFILE, GIT ET DOXYGEN111

14.5.2.2          Le rØsultat suivant :

est obtenu avec le code suivant (syntaxe markdown) :

Header 1 {#labelid}

========

## Header 2 ## {#labelid2}

[Link text](#labelid)

[Link text](@ref labelid)

-   Item 1

More text for this item. - Item 2 + nested list item.

+ another nested item.

-   Item 3

1.    First item.

2.    Second item.

__double underscores__

The link text]()

[The link text]( "Link title")

[The link text]( "Link title")

[The link text]()

[The link text](@ref MyClass)

![Caption text]()

![Caption text]( "Image title")

![Caption text][img def]

![img def]

[img def]: "Optional Title"

> <>

<>

<>

<>

First Header | Second Header

------------- | -------------

Content Cell | Content Cell

Content Cell | Content Cell

| Right | Center | Left |

| ----: | :----: | :---- |

| 10 | 10 | 10 |

| 1000 | 1000 | 1000 |

This is a paragraph introducing:

~~~~~~~~~~~~~~~~~~~~~ a one-line code block ~~~~~~~~~~~~~~~~~~~~~

~~~~~~~~~~~~~~~{.c}

int func(int a,int b) { return a*b; }

~~~~~~~~~~~~~~~

‘

also a fenced code block

‘

Mathematical Inline Formula: \f$\sqrt{(x_2-x_1)^2+(y_2-y_1)^2}\f$.

or

\f[

|I_2|=\left| \int_{0}^T \psi(t)

\left\{ u(a,t)-

\int_{\gamma(t)}^a

\frac{d\theta}{k(\theta,t)}

\int_{a}^\theta c(\xi)u_t(\xi,t)\,d\xi

\right\} dt

\right|

\f] or

\f{eqnarray*}{

g &=& \frac{Gm_2}{r^2} \\

&=& \frac{(6.673 \times 10^{-11}\,\mbox{m}^3\,\mbox{kg}^{-1}\,

\mbox{s}^{-2})(5.9736 \times 10^{24}\,\mbox{kg})}{(6371.01\,\mbox{km})^2}

\\

&=& 9.82066032\,\mbox{m/s}^2

\f}

14.5.3               Fichier de commentaires avec la syntaxe markdown

On peut Øcrire le chier du projet avec la syntaxe markdown . Voici une rØfØrence sur Markdown. avec

14.6               Compte rendu de projet en pdf et html avec Lyx

Lyx est un logiciel qui produit des documents scienti ques en di Ørents formats (pdf, html, etc).

La documentation est bien faite. Voici quelques informations prØcises.

On peut exporter en html : Exporter en xhtml avec Lyxhtml. Insertion de videos sous format gif animØ.

Pour des prØsentation on peut choisir le style Beamer

Chapitre 15

Interface interactive pour le C++

Il y a le projet cling. Voir Cling.

Il y a le projet qui permet d’e ectuer du C++ scienti que de fa on interactive sur le cloud .

116

Troisi?me partie

ComplØments sur les librairies du langage C++

117

118

Dans les chapitres suivants nous prØsentons quelques librairies C++ utiles.

Nous conseillons de consulter la page de Boost qui prØsente d’autres librairies.

Voici en particulier une liste de librairies pour l’audio, le graphisme.

Chapitre 16

Librairie Root : graphisme et autre..

(complØments)

Nous avons dØj vu une introduction cette librairie en Section 3.4. Cette Section apporte quelques complØments.

Voici aussi la Documentation gØnØrale.

16.1          Graphisme de base 2Dim

16.1.1          Objets graphiques

Voici quelques exemples de Remarquez que au dØbut du programme on ajoute une ligne spØci que par exemple #include <TLine.h> si on utilise la classe TLine.

#include <TApplication.h>

#include <TCanvas.h>

#include <TLine.h>

#include <TEllipse.h>

119

#include <TMarker.h>

#include <TBox.h> #include <TText.h>

int main()

{

TApplication theApp("App", nullptr, nullptr);

//.. La fenetre

TCanvas *c=new TCanvas("titre","titre",400,400); c->Range(0,0,1,1);

//.. une ligne bleue

TLine *l=new TLine(0.1,0.5,0.3,0.9); // x1,y1,x2,y2. l->SetLineColor(kBlue); // bleu l->Draw();

//.. Une Ellipse (ou cercle)

TEllipse *e= new TEllipse(0.2,0.3,0.1); // (centre (x,y) et rayon r e->Draw();

//.. Un point

TMarker *m=new TMarker(0.3,0.4,8); // (x,y) et 6 ou 8: forme du

Marker m->SetMarkerColor(kPink); m->Draw();

//.. Un rectangle vert

TBox *p=new TBox(0.15,0.6,0.25,0.7); // on precise les coins bas-gauche (x1,y1) et haut droit (x2,y2) :

p->SetFillColor(kGreen); p->Draw();

//.. Du texte

c->Update(); // Montre le dessin

();

}

16.1.2            Dessiner dans plusieurs fenŒtres

Avec la classe TCanvas qui hØrite de TPad.

#include <TApplication.h>

#include <TCanvas.h> #include <TMarker.h> int main()

{

TApplication theApp("App", nullptr, nullptr);

TCanvas c1("c1","fenetre1",400,400); // creation de la fenetre c1

TCanvas c2( "c2","fenetre2",400,400); // creation de la fenetre c2

TMarker *m1=new TMarker(0.3,0.4,8); // un point TMarker *m2=new TMarker(0.3,0.4,8); // un point

m2->SetMarkerColor(kRed);

(); // choix de la fenetre c1 pour le prochain dessin m1->Draw(); // dessin du point 1

(); // choix de la fenetre c2 pour le prochain dessin m2->Draw(); // dessin du point 2

(); }

16.1.3               Un cadre avec des axes graduØs : DrawFrame

Avec la classe TPad.

#include <TApplication.h> #include <TCanvas.h> int main()

{

TApplication theApp("App", nullptr, nullptr);

TCanvas *c=new TCanvas("titre","titre",400,400); double x1(0),y1(0),x2(2),y2(1); // position du cadre c->DrawFrame(x1,y1,x2,y2);

();

}

On peut complØter le dessin du cadre de la fa on suivante. On rØcup?re un pointeur sur un histogramme de la classe TH1, et on a acc?s aux fonctions membres pour modi er le cadre, par exemple :

#include <TApplication.h>

#include <TCanvas.h>

#include <TEllipse.h> #include <TH1F.h>

int main()

{

TApplication theApp("App", nullptr, nullptr);

TCanvas *c=new TCanvas("titre","titre",400,400); double x1(0),y1(0),x2(10),y2(10); // position du cadre

TH1F *h =c->DrawFrame(x1,y1,x2,y2); TEllipse e(2,3,1); e.Draw(); h->SetXTitle("x"); h->SetYTitle("y");

h->SetMinimum(-2); // change les bornes en y

h->SetMaximum(8);

h->SetBins(1000,1,5); // change les bornes en x: 1->5 c->Update(); // Montre le dessin

();

}

16.1.4             Un seul axe graduØ : TGaxis

#include <TApplication.h>

#include <TCanvas.h> #include <TGaxis.h> int main()

{

TApplication theApp("App", nullptr, nullptr); TCanvas *c=new TCanvas("titre","titre",400,400); double x1(0.1),y1(0.5),x2(0.9),y2(0.5); // position de l’axe double v1(0),v2(1); // graduations extremes TGaxis axe(x1,y1,x2,y2,v1,v2,510,""); axe.SetTitle("x"); // met le titre sur l’axe

(); (); }

16.1.5         Couleurs

voir

#include <TApplication.h>

#include <TCanvas.h>

#include <TStyle.h>

#include <TColor.h>

#include <TH3.h> //==================== main ()

{

TApplication theApp("App", nullptr, nullptr); //---- on defini une palette de 5 couleurs const int n = 5; //nbre de couleurs float rgb[n * 3] = {0.9f, 0.60f, 0.f,

0.f, 1.f, 1.f, 1.f, 0.f, 0.f,

0.f, 1.f, 0.f, 1.f, 1.f, 0.f};

int palette[n] = {0}; for (Int_t i = 0; i < n; ++i)

palette[i] = TColor::GetColor(rgb[i * 3], rgb[i * 3 + 1], rgb[i

* 3 + 2]);

gStyle->SetPalette(n, palette); //------------------------

gStyle->SetCanvasPreferGL(kTRUE); // permet d’utiliser openGL TCanvas *c = new TCanvas("glc","TH3 Drawing", 400,400); int N=50;

double x1=-3,x2=3,y1=-3,y2=3,z1=-3,z2=3;

TH3D *h = new TH3D("h", "h", N, x1, x2, N, y1, y2, N, z1, z2); for(int i=0;i<N;i++) for(int j=0;j<N;j++) for(int k=0;k<N;k++)

{

double x= (x2-x1)*i*1./N+x1; double y= (y2-y1)*j*1./N+y1; double z= (z2-z1)*k*1./N+z1;

double f= exp(-x*x-y*y-z*z); // formule f(x,y,z)

h->SetBinContent(i+1,j+1,k+1, f);

}

h->SetFillColor(kBlue); h->SetContour(n);

h->Draw("gliso");// glbox1 glbox glcol gliso

(); }

16.2         Graphisme 1D

Voici quelques exemples d’utilisation des Pour utiliser ces exemples, il faut remplacer les parties (C) de l’exemple de la Section 3.4.2, par le code ci-dessous.

Attention : la ligne #include <..> mentionnØe chaque fois est mettre en haut de votre programme.

16.2.1      Courbe a partir de l’expression d’une formule y = f (x) : TF1

Avec la classe TF1.

16.2.1.1         Exemple            partir d’une formule littØrale :

#include <TApplication.h> #include <TF1.h> int main()

{

TApplication theApp("App", nullptr, nullptr);

//------------

TF1 *f1 = new TF1("f1","sin(x)/x",0,10);

f1->Draw();

(); }

16.2.1.2        MŒme rØsultat            partir d’une fonction C++

#include <TApplication.h>

#include <TF1.h>

//--------------------double F(double *px, double *p)

{ double x= px[0]; return sin(x)/x; }

//--------------int main()

{

TApplication theApp("App", nullptr, nullptr);

//------------

TF1 *f1 = new TF1("f1",F,0,10);

f1->Draw();

(); }

16.2.2 Histograme 1Dim ou Courbe y (x) partir de tableau de

valeurs y (i) : TH1D

Avec la classe TH1D.

#include <TApplication.h> #include <TH1.h> int main()

{

TApplication theApp("App", nullptr, nullptr);

//------------

int nx(10); // nombre de points

double xmin(0.0),xmax(1.0); // graduation de l’axe x TH1D *h1=new TH1D("nom","titre",nx,xmin,xmax); h1->SetXTitle("x"); h1->SetYTitle("y");

for(int i=1;i<=nx;i++) // remplissage

{ double z=i*i; h1->SetBinContent(i,z);

}

h1->SetStats(0);// pas de boite de resultats stat h1->SetMarkerStyle(8);//8: gros point h1->Draw("L P"); // option L: ligne ou P: marker

(); }

16.2.2.1           ReprØsentation en diagramme          Camembert        (Pie Chart)

Voir TPie.

MŒme exemple ci-dessus avec l’option h1->Draw("PIE 3d"); et h1->Draw("PIE rsc");

16.2.3                ReprØsentation d’un tableau de valeurs y (i) sous forme de

camembert ou Pie

Voir TPie.

#include <TApplication.h> #include <TPie.h> int main()

{

TApplication theApp("App", nullptr, nullptr);

//------------

int couleurs[5] = {2,3,4,5,6};

TPie *p = new TPie("p", "titre", n, valeurs, couleurs); p->Draw();

();

}

16.2.4 Courbe paramØtrØe (x(i),y (i)) avec axes partir de tableaux de valeurs x(i),y (i) : TGraph

Attention : si les valeurs x(i) son ØquidistribuØes il est prØfØrable d’utiliser la classe TH1 ci-dessous. La classe TGraph est prØfØrables si les valeurs x(i) et y (j) ne sont pas

ØquidistribuØes.

Avec la classe TGraph.

Voir Options de dessin.

Exemple :

#include <TApplication.h>

#include <TGraph.h>

#include <TPad.h> #include <TAxis.h> int main()

{

TApplication theApp("App", nullptr, nullptr);

//---- creation de tableaux

int n = 100;

double x[100], y[100];

for (int i=0;i<n;i++) // remplissage

{

double r = i; x[i] = r*cos(0.3* i);

y[i] = r*sin(0.3 * i);

}

//--- dessin

TGraph *gr = new TGraph(n,x,y); gr->SetLineColor(kBlue); gr->SetMarkerColor(kRed);

gr->SetMarkerStyle(6); // 6:petit cercle 8: gros

gr->GetXaxis()->SetTitle("X"); gr->GetYaxis()->SetTitle("Y"); gr->Draw("A C P"); // AC: trace un segment entre les points

// gPad->BuildLegend(); // rajoute la legende

(); }

16.2.5             Courbe paramØtrØe (r (i),? (i)) reprØsentØe en coordonnØes

                           polaire           partir de points r (i),? (i)

Voir Options de dessin.

#include <TApplication.h>

#include <TCanvas.h> #include <TGraphPolar.h> int main()

{

TApplication theApp("App", nullptr, nullptr);

TCanvas * c = new TCanvas("CPol","TGraphPolar Example",500,500); int N=50; double theta[N]; double radius[N];

for (int i=0; i<N; i++)

{

theta[i] = i*(2*M_PI/N);

radius[i] = sin(theta[i])* sin(theta[i]) +1;

}

TGraphPolar * grP1 = new TGraphPolar(N, theta, radius);

grP1->SetFillColor(kRed); grP1->Draw("f"); c->Update(); ();

}

Autre exemple :

#include <TApplication.h>

#include <TCanvas.h> #include <TGraphPolar.h> int main()

{

TApplication theApp("App", nullptr, nullptr);

TCanvas * c = new TCanvas("CPol","TGraphPolar Example",500,500); double theta[8]; double radius[8]; double etheta[8];

double eradius[8]; for (int i=0; i<8; i++) { theta[i] = (i+1)*(M_PI/4.); radius[i] = (i+1)*0.05; etheta[i] = M_PI/8.; eradius[i] = 0.05;

}

TGraphPolar * grP1 = new TGraphPolar(8, theta, radius, etheta, eradius); grP1->SetTitle("TGraphPolar Example"); grP1->SetMarkerStyle(20); grP1->SetMarkerSize(2.); grP1->SetMarkerColor(kBlue); grP1->SetLineColor(kRed); grP1->SetLineWidth(3); grP1->Draw("PE"); c->Update(); ();

}

16.2.6 CrØe histogramme ou fonction 1D y = f (x) par tirage alØatoire et ajustement par une formule : TF1

Remarque 16.2.1. voir

Code :

#include <TRandom.h>

#include <TApplication.h>

#include <TCanvas.h>

#include <TF1.h>

#include <TH1.h> #include <iostream> using namespace std; int main()

{

TApplication theApp("App", nullptr, nullptr);

TCanvas *c=new TCanvas("titre","titre",400,400);

//------- cree histo avec tirage aleatoire avec loi gaussienne -----------int nbin=100; double xmin=-3,xmax=3;

TH1D *h=new TH1D("TW","TW",nbin,xmin,xmax); gRandom->SetSeed(); // initialise sur l’horloge for(int i=1;i<=1e5;i++) //tirages

{

double x= gRandom->Gaus(0,1); // c’est P(x)=exp(-0.5*(x/sigma)^2) h->Fill(x);

} h->Draw();

//---- calcule integrale et normalise l’histogramme ----------double I= h->Integral();

h->Scale(1/I); h->Draw();

//--- Fit l’histogramme avec une Gaussienne --------------

TF1 *f1 = new TF1("f1","gaus"); // ou pol0, pol1, polN pour polynome degre N, ou expo h->Fit("f1");

cout<<"Ecart type ="<<f1->GetParameter(2)<<endl;

//--- montre fenetres de commandes --h->DrawPanel(); h->FitPanel();

();

}

16.2.7               Superposition d’histogrammes : THStack

Classe THStack.

#include <TApplication.h>

#include <TH1.h> #include <THStack.h> int main()

{

TApplication theApp("App", nullptr, nullptr); //---- cree un histogramme -------int nx(10); // nombre de points

double xmin(0.0),xmax(1.0); // graduation de l’axe x TH1D *h1=new TH1D("nom","titre",nx,xmin,xmax); h1->SetXTitle("x"); h1->SetYTitle("y");

for(int i=1;i<=nx;i++) // remplissage

{ double z=i*i; h1->SetBinContent(i,z);

}

h1->SetFillColor(kGreen);

//-------------- une copie ---------TH1D *h2 = (TH1D*)h1->Clone(); h2->SetFillColor(kRed);

//------------------------THStack *hs = new THStack("hs","");

hs->Add(h1); hs->Add(h2);

hs->Draw(); // dessin les uns sur les autres. nostack: superposes

, nostackb, lego1

(); }

16.3         Graphisme 2D

16.3.1      Surface 2Dim : z = f (x,y) partir d’un tableau de valeurs z (i,j) : TH2D

Avec la classe TH2D.

#include <TApplication.h> #include <TH2D.h> int main()

{

TApplication theApp("App", nullptr, nullptr);

//-----------int nx(10),ny(10);

double xmin(0),xmax(1),ymin(0),ymax(2);

TH2D *h= new TH2D("h1","titre",nx,xmin,xmax,ny,ymin,ymax); h->SetXTitle("x");

h->SetYTitle("y");

h->SetStats(kFALSE); // pas de panneau stat for(int i=1;i<=nx;i++) // remplissage for(int j=1;j<=ny;j++)

{ double z=i*j;

h->SetCellContent(i,j,z);

}

h->Draw("surf2"); // essayer options: surf1, surf3,surf4,lego

//-------------------

(); }

16.3.2      Surface 2D a partir de l’expression d’une formule z = f (x,y) : TF2

Avec la classe TF2.

Voici le rØsultat du programme suivant avec di Ørentes options, en particulier, reprØsentation cylindrique, polaire, spherique et en utilisant openGL.

#include <TApplication.h>

#include <TF2.h> #include <TStyle.h> int main()

{

//------------

gStyle->SetCanvasPreferGL(kTRUE); //si option gl.. cidessous TF2 *f2 = new TF2("f2","-sin(x)*sin(y)/(x*y)",0,5,0,5); f2->Draw("surf4"); // glsurf1, glsurf2, glsurf3, glsurf3, glsurf1cyl,

glsurf1pol, glsurf1sph (); }

16.3.3 Surface 2D z (x,y) partir d’un ensemble arbitraire de points x(i),y (i),z (i) : TGraph2D

La classe TGraph2D permet de dessiner une surface z (x,y) partir de la donnØe d’un ensemble de N points (x_i,y_i,z_i).

#include <TApplication.h>

#include <TGraph2D.h>

#include <TCanvas.h>

#include <TRandom.h> #include <TStyle.h> using namespace std; main ()

{

TApplication theApp("App", nullptr, nullptr);

TCanvas *c = new TCanvas("c","Graph2D example",0,0,600,400);

double x, y, z, P = 6.; int N = 200;

TGraph2D *g = new TGraph2D(); TRandom *r = new TRandom(); for(int i=0; i<N; i++)

{

x = 2*P*(r->Rndm(N))-P; // choix de (x,y) au hasard dans le carrØ

[-P,P] y = 2*P*(r->Rndm(N))-P;

z = (sin(x)/x)*(sin(y)/y)+0.2; // formule de la surface lisse g->SetPoint(i,x,y,z); // ajoute point (x,y,z) a l’ensemble

}

gStyle->SetPalette(1); // couleurs. autres choix: 0, 1, 2 g->Draw("tri1"); // autres choix: tri, triw, tri1, tri2, p,po, pcol,line (); }

16.3.4             Champ de vecteur en dimension 2

            /// Ce code dessine un champ de vecteur spØci Ø       deux dimensions.

#include <TApplication.h>

#include <TCanvas.h>

#include <TArrow.h>

#include <TLine.h>

#include <math.h> #include <iostream> using namespace std;

///--- definition du champ de vecteur

void vect(double x, double y, double &vx, double &vy)

{

vx = x; vy= -y;

}

//---------------------------------int main()

{

TApplication theApp("App", nullptr, nullptr);

//------------

double xmin=-1, xmax=1, ymin=-1,ymax=1; // coordonnØes TCanvas *c=new TCanvas("c","c",500,500); // fenetre

//-----------------double N=20; // nbre d’echantillons double dx=(xmax-xmin)/N; double dy=(ymax-ymin)/N; for (int i=0; i<N; i++)

for (int j=0; j<N; j++)

{ double x=xmin + dx*i;

double y=ymin + dy*j; double vx,vy;

vect(x,y,vx,vy);// calcul les coordonnØes du champ de vecteur

vx *= dx *1; // normalise vy *= dy *1;

double n=sqrt(vx*vx+vy*vy); // norme

TArrow *t= new TArrow(x,y,x+vx,y+vy,dx*n);

// TLine *t= new TLine(x,y,x+vx,y+vy); t->Draw(); } // for i,j

// -donne la main a l’utilisateur (A)

(); }

16.4         Graphisme 3D

16.4.1                Des points dans R³ : TPolyMarker3D

Doc : TPolyMarker3D.

Remarque : ensuite avec le menu on peut rØgler leur opacitØ etc

#include <TApplication.h> #include <TPolyMarker3D.h>

int main()

{

TApplication theApp("App", nullptr, nullptr);

//------------

int N=1000;//nbre de points

TPolyMarker3D *p = new TPolyMarker3D(N); for( int i = 0; i < N; i++ )

{

double theta=i/double(N)*2*M_PI;

double x=cos(theta), y=sin(theta), z=cos(10*theta);

p->SetPoint( i, x, y, z );

}

p->SetMarkerSize( 1 ); p->SetMarkerColor( kBlue); p->SetMarkerStyle( 8 );

p->Draw();

(); }

16.4.2               Surface dØterminØe par f (x,y,z) = 0 : TF3

Ici la surface dans R³ est dØterminØe par l’Øquation f (x,y,z) = 0 avec f donnØe par son expression.

On utilise la classe TF3.

the options "FB" and "BB" suppress the "Front Box" and "Back Box" around the plot.

#include <TApplication.h>

#include <TCanvas.h>

#include <TStyle.h>

#include <TPaveLabel.h>

#include <TFormula.h>

#include <TF3.h>

// utiliser la mollette de la souris pour zoomer // et touche ’s’ pour changer la couleur main ()

{

TApplication theApp("App", nullptr, nullptr);

//--- prepare la fenetre 3D gStyle->SetCanvasPreferGL(1); TCanvas *cnv = new TCanvas("glc", "TF3: Klein bottle", 200, 10,

TPad *tf3Pad = new TPad("box", "box", 0.04, 0.04, 0.96, 0.8); tf3Pad->Draw();

//--- definition et dessin de l’objet 3D

TFormula f1 = TFormula("f1", "x*x + y*y + z*z + 2*y - 1");

TFormula f2 = TFormula("f2", "x*x + y*y + z*z - 2*y - 1");

TF3 *tf3 = new TF3("Klein Bottle","f1*(f2*f2-8*z*z) + 16*x*z*f2",

-3.5, 3.5, -3.5, 3.5, -2.5, 2.5); tf3->SetFillColor(kRed); tf3Pad->cd();

tf3->Draw("gl"); // gl, default, kMaple0, kMaple1, kMaple2 (touche

’s’) (); }

16.4.3              Fonction f (x,y,z) ?R : TH3

Doc : TH3.

Dessin avec openGL et en option : dessin de la surface de niveau de f ( gliso ) ou boules montrant la valeur de f ( glbox ) ou densitØ transparente glcol .

Remarques : avec l’option surface de niveau gliso la touche c permet de voir des coupes et les dØplacer avec la souris.

#include <TApplication.h>

#include <TCanvas.h>

#include <TStyle.h> #include <TH3.h> main ()

{

TApplication theApp("App", nullptr, nullptr); gStyle->SetCanvasPreferGL(kTRUE); // mettre avant declaration de

la fenetre TCanvas

TCanvas *c = new TCanvas("glc","TH3 Drawing", 400,400); int N=30;

double x1=-3,x2=3,y1=-3,y2=3,z1=-3,z2=3;

TH3D *h = new TH3D("h", "h", N, x1, x2, N, y1, y2, N, z1, z2); for(int i=0;i<N;i++) for(int j=0;j<N;j++) for(int k=0;k<N;k++)

{

double x= (x2-x1)*i*1./N+x1; double y= (y2-y1)*j*1./N+y1; double z= (z2-z1)*k*1./N+z1;

double f= exp(-x*x-y*y-z*z); // formule f(x,y,z)

h->SetBinContent(i+1,j+1,k+1, f);

}

h->SetFillColor(kBlue);

double levels[2] = {2, 2.5}; // valeurs des niveaux h->SetContour(2,levels); // on choisit deux niveaux pour le dessin

iso h->Draw("gliso");// glbox1 glbox glcol gliso

(); }

16.4.3.1 Dessin d’une surface de niveau souhaitØe Sans l’option gl , mais seulement iso , la surface de niveau dessinØe est pour la valeur

Voici un exemple qui dessine la surface ^px² + y² + z² = 2 c’est dire la sph?re de rayon 2 :

#include <TApplication.h>

#include <TCanvas.h>

#include <TStyle.h> #include <TH3.h> main ()

{

TApplication theApp("App", nullptr, nullptr);

//------------------double C0=2; // niveau souhaite

TCanvas *c = new TCanvas("glc","TH3 Drawing", 400,400); int N=30;

double x1=-3,x2=3,y1=-3,y2=3,z1=-3,z2=3;

TH3D *h = new TH3D("h", "h", N, x1, x2, N, y1, y2, N, z1, z2); double sum=0; for(int i=0;i<N;i++) for(int j=0;j<N;j++) for(int k=0;k<N;k++)

{

double x= (x2-x1)*i*1./N+x1; double y= (y2-y1)*j*1./N+y1; double z= (z2-z1)*k*1./N+z1; double f= sqrt(x*x+y*y+z*z); // fonction h->SetBinContent(i+1,j+1,k+1, f); sum+=f;

}

double delta = -sum + (N*N*N) *C0;

h->SetBinContent(1,1,1, h->GetBinContent(1,1,1)+delta); h->SetFillColor(kBlue); h->Draw("iso"); ();

}

16.4.3.2             Dessin d’une courbe sur une surface

On peut combiner le dessin d’une iso-surface de la Section 16.4.3.1 avec le dessin d’une courbe de la Section 16.4.1 (mais sans l’option GL malheuresement).

Voici un exemple : un grand cercle Øquateur sur la sph?re de rayon 2. Malheuresement, la partie arri?re de la courbe n’est pas cachØe.

#include <TApplication.h>

#include <TCanvas.h>

#include <TStyle.h>

#include <TH3.h>

#include <TPolyMarker3D.h>

main ()

{

TApplication theApp("App", nullptr, nullptr);

//------------------double C0=2; // niveau souhaite

TCanvas *c = new TCanvas("glc","TH3 Drawing", 400,400); int N=30;

double x1=-3,x2=3,y1=-3,y2=3,z1=-3,z2=3;

TH3D *h = new TH3D("h", "h", N, x1, x2, N, y1, y2, N, z1, z2); double sum=0; for(int i=0;i<N;i++) for(int j=0;j<N;j++) for(int k=0;k<N;k++)

{

}

double delta = -sum + (N*N*N) *C0;

h->SetBinContent(1,1,1, h->GetBinContent(1,1,1)+delta); h->SetFillColor(kBlue); h->Draw("iso"); //------------

int N2=1000;//nbre de points

TPolyMarker3D *p = new TPolyMarker3D(N2); for( int i = 0; i < N2; i++ )

{

double theta=i/double(N2)*2*M_PI; double x=2*cos(theta), y=2*sin(theta), z=0;

p->SetPoint( i, x, y, z );

}

p->SetMarkerSize( 1 ); p->SetMarkerColor( kRed); p->SetMarkerStyle( 8 );

p->Draw();

(); }

16.5          Utilisation de la souris

Dans une fenetre gaphique, chaque objet capture la souris si elle passe proximitØ. Pour l’observer, vous pouvez activer l’option EventStatus dans le menu de la fenetre.

Voici un code complet qui de nit une classe que l’on appelle Fenetre (hØritØe de la classe TCanvas). La nouveautØ est la fonction HandleInput() qui est appelØe chaque fois que la souris bouge devant la fenetre. Lorsque le programme execute l’instruction (); il est en attente d’Øv?nements provenant du clavier ou de la souris. Si un tel Øv?nement se produit, il appelle la fonction void HandleInput(EEventType event, Int_t px, Int_t py), en passant les param?tres de l’Øv?nement. C’est donc dans cette fonction que vous allez rajouter du code (ou faire appel d’autres fonctions).

#include <iostream> using namespace std; #include <TCanvas.h>

#include <TMarker.h>

#include <TApplication.h>

#include <TEllipse.h>

//====Ma Classe Fenetre================================

class Fenetre: public TCanvas

{ public:

// constructeur

Fenetre(Text_t* name, Text_t* title, Int_t ww, Int_t wh) : TCanvas(name,title,ww

{ }

// - Cette fonction est appelle si la souris s’agitte. void HandleInput(EEventType event, Int_t px, Int_t py)

{

                         //             affiche l’etat de la souris

                         //                  convertit la position en pixel px,py en coordonnees (x,y)

double x = gPad->AbsPixeltoX(px); double y = gPad->AbsPixeltoY(py); // si bouton gauche appuye dessine un point if(event==1)

{

TMarker *m=new TMarker(x,y,8);

m->Draw(); Update();

}

                         //                  Event clavier

if (event==kKeyPress) // touche appuyØe

{

cout<<"touche px="<<px<<endl; switch (px)

{

//   change de mode (tempØrØ <-> juste) case ’m’: cout<<"Touche m appuyØe"<<endl;

break;

}; // switch px

} // if event

}

};

///-------------------------------------------int main()

{

TApplication theApp("App", nullptr, nullptr);

Fenetre *c = new Fenetre("c", "fenetre1", 400,400); // crØe une fenetre double xmin(0),ymin(0),xmax(5),ymax(5);

c->Range(xmin,ymin,xmax,ymax); // coordonnees de la fenetre (optionnel,

par defaut: 0-1) ();

}

16.5.1                 Pour qu’un objet graphique capture les evenements souris

Dans l’exemple suivant une ellipse change d’Øtat selon les evenement souris (clique gauche). Pour cela il faut crØer une classe dØrivØe qui poss?de la fonction ExecuteEvent(int event, int px, int py).

#include <iostream> using namespace std; #include <TCanvas.h>

#include <TApplication.h>

#include <TEllipse.h> //==============

class Cercle: public TEllipse

{ public:

// constructeur

Cercle(double x, double y, double r): TEllipse(x,y,r)

{ } int col = kRed;

// - Cette fonction est appelle si la souris s’agitte.

void ExecuteEvent(int event, int px, int py)

{

//--- change l’epaisseur du cercle

SetLineWidth(3);

Draw(); gPad->Update(); SetLineWidth(1);

Draw();

//--- si clique gauche if(event == 1)

{ if(col == kRed)

col = kBlue; else

col = kRed;

Draw();

}

}

};

///-------------------------------------------int main()

{

TApplication theApp("App", nullptr, nullptr);

TCanvas *c = new TCanvas("c", "fenetre1", 400,400); // crØe une fenetre double xmin(0),ymin(0),xmax(4),ymax(4);

c->Range(xmin, ymin, xmax, ymax); // coordonnees de la fenetre (optionnel,

par defaut: 0-1)

Cercle *C1= new Cercle(3,2,0.5);

C1->SetFillColor(kRed);

C1->Draw();

Cercle *C2= new Cercle(1,2,0.5);

C2->SetFillColor(kRed);

C2->Draw(); (); }

16.5.2                Pour gØrer la souris lorsque le programme calcule

Si votre programme est lancØ dans un calcul interminable, et que vous vouliez cependant modi er des param?tres par l’intermØdiaire de la souris ou d’un commande clavier, il faut dans votre boucle mettre la commande suivante :

gSystem->ProcessEvents(); // avec #include <TSystem>

Ainsi si la souris est actionnØe, dans l’exemple ci-dessus, la fonction Fenetre::ExecuteEvent sera appelØe.

16.6         Comment crØer un         chier gif animØ

Voici un exemple complet qui permet de crØer un chier animØ partir d’images crØØes par root.

Travail prØalable :

1.    Fichiers           tØlØcharger et sauver dans son rØpertoire : et .

2.    Il faut avoir installØ le logiciel ,

#include <TApplication.h>

#include <TCanvas.h>

#include <TEllipse.h>

#include ""

///-----------------------------------int main()

{

TApplication theApp("App", nullptr, nullptr); TCanvas *c= new TCanvas("c","fenetre",400,400); double xmin(-1),ymin(-1),xmax(2),ymax(2); c->Range(xmin,ymin,xmax,ymax); int periode = 10; // temps entre chaque image en 1/100e sec.

int imin=1, imax=30; for(int i =imin; i<=imax; i++)

{ double x = i/(double)imax;

TEllipse e(x,0.5,1);

e.Draw(); // dessine l’ellipse

c->Update();

Animation(c,i,imin,imax,"film",periode); // -> crØe fichier

} (); }

16.7              Boutons de commandes (Widgets et GUI)

Le mot widget est une contraction de windows et gadget . GUI signi e Graphical User Interface .

Documentation

Exemple tr?s complet qui montre presque toutes les possibilitØs et comment le faire : copier/coller. (attention, il y a une erreur : remplacer (char **) par (const char **)).

Voir aussi les nombreux exemples dans /usr/share/doc/root/tutorials/gui que l’on execute avec l’interprØteur et la commande .x nom.C

16.7.1              Exemple simple avec quelques widgets

          Voici un exemple plus simple,       copier/coller, donnant l’interface :

/*! ===========================

*     Exemple  simple d ’ une  fenetre            de commande.

*     I l y a deux           classes :           la         classe Com qui            est       la         fenetre            de commande

*     et qui       permet de commander une    autre   classe A

*     Chaque    classe  a un     lien      vers     l ’ autre            afin      de        pouvoir            communiquer .

*/

#include <TCanvas .h> #include <TGFrame.h>

#include <TGButton .h>

#include <TGComboBox.h>

#include <TGTextEntry .h>

#include <TGLabel .h>

#include <TGProgressBar .h>

#include <TPad.h>

#include <TFrame.h> #include <TH1F.h>

#include<TSystem .h>

#include <TGNumberEntry.h>

#include <TGSlider .h>

#include <TGDoubleSlider .h> #include <TGTripleSlider .h> #include <TGMenu.h>

#include <TApplication .h>

#include <TRootEmbeddedCanvas .h>

#include <thread> #include <chrono>

#include <iostream> using namespace std ; class A; // classe definie aprˆ¤s

*         Description      de    la       classe Com

*/

class Com:            public        TGMainFrame       //        ( derivee d une           fenetre GUI)

{

public        :

                TGMenuBar *fMB;      //     barre     de menu

                TGPopupMenu *fM;       // menu

                 TGTextButton        *fB ;       // bouton

                 TGTextEntry             *fT ;      // zone      texte

                TGLabel                 *fL ;     //       texte      fixe      ecrit      sur     la     fenetre

TGComboBox *fC ;        //         l i s t e  deroulante TGCheckButton *fCB;

                   TGHProgressBar *fH ;        //     barre    de     progres

TGNumberEntry *fNE;

TGHSlider *fS ;

TGDoubleVSlider *fS2 ;

TGTripleHSlider *fS3 ;

                    TRootEmbeddedCanvas *fEC ;        //     fenetre

//???????????????????

               A *a ;       //     lien         vers un objet        a d ’ une       classe A

//?????????????????????

                 Com(A *a_i );         //       constructeur

              ~Com( ) ;    //       destructeur

Bool_t   ProcessMessage (Long_t msg ,           Long_t parm1 ,            Long_t );          //         fonction   appe //=========================================

                 // met a      jour     les      valeurs     de    la     fenetre

};

/*!===============

* Une        classe     pour      effectuer      un     calcul      . . .

*/

class A

{ public :

double x ;

//????????????? void  Calcul ()

{ cout<<"calcul : " ;

for (x=1; x<=50; x++)

{ this_thread : : sleep_for ( chrono : : milliseconds        {100}); //         attend

0.5 ms//              attente , com?>Met_a_jour ( ) ;

cout<<x<<","<<flush ;

}

cout<<endl ;

}

//????????????

              Com *com;     //      pointeur      vers      l ’ objet       fenetre     de     control

void Lance_commandes()

{

TApplication theApp("App" , NULL,NULL); com=           new Com( this );          //           cree     fenetre            de        control et         l ’ associe         a l ’ objet         present theApp .Run( ) ; //????donne            la         main a l ’ u t i l i s a t e u r ???

}

};

/*!=====================

Constructeur

*/

Com: :Com(A *a_i)                    : TGMainFrame( gClient?>GetRoot () ,400 ,350)               //    t a i l l e    de    la f

{

a=a_i ; // i n i t i a l i s e le lien vers l ’ objet ˆ controller ( sera utile pour a?>com=this ; //????????????????

                  SetWindowName(" Fenetre         de commandes ");       // nom de      la      fenetre

//????????? Menu ?????????? fMB = new TGMenuBar( this , 35 , 50 , kHorizontalFrame );

//?????boutons ????????????????????????

                           fB= new TGTextButton( this ,"S&tart " ,2);                 //    cree     bouton ,    l e t t r e   t ,    et

code message 2 fB?>Move(100 ,10); // position x , y

fB?>SetToolTipText ("Demarre un calcul . . . " ) ; // texte d ’ aide fB?>Associate ( this ); fB?>Resize (80 , fB?>GetDefaultHeight ( ) ) ; // t a i l l e (x , y)

                      //.. Label = texte              fixe . . . . . . . . . . . . . . . . .

fL= new TGLabel( this , new TGString(" Label = Texte fixe ")); fL?>Move(10 ,40); // position x , y / / . . . Zone de texte . . . . . . . . . . . . . . . .

                 string         text="toto ";

fT = new TGTextEntry( this , text . c_str () ,1); //code 1 fT?>Move(10 ,70);  //         position           x , y fT?>Resize (40 ,fT?>GetDefaultHeight ( ) ) ;  //         t a i l l e            (x , y)

               char        buf [100]=" texte ";

fT?>Associate ( this );

                    //??????? Liste Combo          ????

fC = new TGComboBox( this ,   88); fC?>AddEntry(" entree 1" ,1); fC?>AddEntry(" entree   2" ,2); fC?>Resize (150 ,         20);//   t a i l l e        (x , y) fC?>Select (2);   //         selection  a          priori

AddFrame(fC , new TGLayoutHints(kLHintsTop | kLHintsLeft ,5 ,5 ,5 ,5)); // mis fC?>Move(10 ,100); // position

                  //????? Progress         Bars??????????????

                         fH?>ShowPosition (kTRUE,kFALSE," valeur :              %.0 f ");

//??????????? Sliders ??????????? fS = new TGHSlider( this ,150 , kSlider1 | kScaleDownRight , 2 ) ; // simple , Id=2 fS?>SetRange (0 ,50); fS?>SetPosition (39); fS?>Move(10 ,200);

fS2 = new TGDoubleVSlider( this ,100 , kDoubleScaleNo , 3 ) ; //double fS2?>SetRange ( ?10 ,10); fS2?>Move(200 ,200);

fS3 = new TGTripleHSlider ( this ,100 , kDoubleScaleBoth ,4 , // t r i p l e kHorizontalFrame );

fS3?>SetConstrained (kTRUE); fS3?>SetRange (0 ,10); fS3?>SetPosition (2 ,3); fS3 ?>SetPointerPosition ( 2 . 5 ) ; fS3?>Move(250 ,200);

//???????? entree numerique ?????? double val =3.1415; fNE = new TGNumberEntry( this , val , 5 , 400 ,(TGNumberFormat : : EStyle ) 2); // fNE?>Associate ( this ); fNE?>Move(10 ,250);  //         position

//????? Fenetre              Canvas ??????????????

                       fEC = new TRootEmbeddedCanvas(" ec1 " ,            this ,     200 ,     100);

AddFrame(fEC ,           new TGLayoutHints(kLHintsTop          |          kLHintsLeft      |          kLHintsExpandX kLHintsExpandY ,        5 ,        5 ,        5 ,        5));       //         les        opti

fEC?>Move(200 ,10);

TCanvas *c = fEC?>GetCanvas ( ) ;

c?>DrawFrame(0 ,0 ,1 ,1); c?>Update ( ) ;

        //        c?>Modified ( ) ;

/ / . . . . Check Button fCB= new TGCheckButton( this , " : bouton check " ,420); fCB?>SetToolTipText (" texte d ’ aide pour bouton check "); fCB?>Associate ( this ); fCB?>Resize (120 , fCB?>GetDefaultHeight ( ) ) ; fCB?>Move(10 ,280);

//????????????

              MapWindow( ) ;     //     dessin     de    la     fenetre

}

/*!====================================

*     Destructeur

*/

Com::~Com()

{

delete   fB ; delete  fT ;

delete   fH ; delete  fC ; }

/*!====================================

*     Fonction            appelee           lorsque            l ’ u t i l i s a t e u r       agit      sur       la         fenetre  de commandes

*     ?> I c i   on gˆ¤re          les        actions

*/

Bool_t Com: : ProcessMessage (Long_t msg ,           Long_t p1 ,      Long_t p2) {

int M = GET_MSG(msg) , S=GET_SUBMSG(msg );

                    cout<<" M = "<<M<<"             S = "<<S<<"          p1="<<p1<<"          p2="<<p2<<endl ;

                switch     (M)

{

               case    1:

                            switch      (S)

{

                           case    3:

switch (p1)

{

                                        case    2:

cout<<"bouton 2"<<endl ;

a?>Calcul ( ) ;

break ;

}

break ;

                                                    case    4:

i f (p1==420)

{

                                                                                                         cout<<"bouton       check    . .     "<<endl ;

i f (fCB?>IsOn ()) cout<<"  on."<<endl ;

else cout<<"            off ."<<endl ;

} break ;

}

                           case    4:

                            switch      (S)

{

                           case    1:

cout<<"texte          change"<<endl ; switch       (p1)

{

case 1: cout<<"Le nouveau texte est : "<<((fT?>GetBuffer())?>GetString break ;

case  400: cout<<"Le nouveau      c h i f f r e        est :     "<<((fNE?>GetNumber()))<<endl ; break ;

} break ;

} break ;

default :

break ;

}

Met_a_jour ( ) ; return kTRUE;

}

/*! =========================================

*    Fonction            appelˆ'e           par une            fonction           externe

*    pour      mettre a          jour      les        valeurs de        la         fenetre ,

*/ void          Com: : Met_a_jour ()

{

                     fH?>SetPosition (a?>x );          //      progress      Bar

              //           gClient?>NeedRedraw(fH );

                     gSystem?>ProcessEvents ( ) ;           //        handle GUI events

}

/*!===Main================================================

*/

int        main( int      argc ,     char     **argv )

{

A *a=new A;

a?>Lance_commandes ( ) ;

                return     0;

}

Remarque 16.7.1.

1. fNumber->GetNumberEntry()->SetToolTipText("Whatever text you want to see here ") permet de rajouter un texte d’aide un widget.

16.7.2                  Exemple simple avec un menu, des zones, des tabs et une

fenetre secondaire

/*! ===========================

*   avec Menu et Tab et       sous     fenetre            libre

*/

#include <TCanvas .h> #include <TGFrame.h>

#include <TGButton .h>

#include <TGMenu.h>

#include <TApplication .h> #include <TGTab.h>

#include <iostream> using namespace std ;

//???? i d e n t i f i e u r s ( int ) pour les messages de commandes enum Command_id

{

M_1, M_2, M_3, M_4, B_1, B_2

};

//====================================

// Fenetre secondaire class Fen2 : public TGTransientFrame

{

public :

//???? constructeur

                                Fen2( const TGWindow *p ,           const TGWindow *main ,         UInt_t w,         UInt_t h ,

UInt_t               options = kVerticalFrame ):                TGTransientFrame(p ,         main , w,     h ,     options )

{

SetCleanup (kDeepCleanup );

//????????? zone avec bouton auto fFrame1 = new TGHorizontalFrame( this , 60 , 20 , kF

auto fOkButton = new TGTextButton(fFrame1 , "&Ok" , B_1 fOkButton?>Associate ( this ); fFrame1?>AddFrame(fOkButton );

AddFrame(fFrame1 );

//?????????

MapSubwindows ( ) ;

                                                                               Resize ( ) ;          //      resize     to     default       size

                                                                                CenterOnParent ( ) ;                                                          //      position  r

MapWindow( ) ;

                                                                                     // fClient ?>WaitFor( this );                  //      otherwise      canvas conte

}

//???? destructeur virtual ~Fen2 ()

{

                                                                             //     Delete      test      dialog      widgets .

}

//?????? virtual void CloseWindow ()

{ cout<<"fenetre       Fen2 fermee ¿?"<<endl ;

                                          // Add protection           against         double?clicks

                                                                             //                                                 fOkButton?>SetState ( kButtonDisabled );

DeleteWindow ( ) ;

}

//?????? virtual Bool_t  ProcessMessage (Long_t msg ,           Long_t p1 ,      Long_t p2)

{

int M = GET_MSG(msg) , S=GET_SUBMSG(msg ); cout<<" Fen2 : M = "<<M<<" S = "<<S<<" p1="<<p1<<"

p2="<<p2<<endl ;

}

};

/*!==========fenetre                       principales ========================

*/

class Com:            public        TGMainFrame

{

public        :

                                    int X=300, Y=150; //          t a i l l e    en     pixels

//===== Constructeur

                          Com()              : TGMainFrame( gClient?>GetRoot () , X,Y)

{

                                           //?? regles       de       positionnement

                                                                                     TGLayoutHints *fLH_TX =                      new TGLayoutHints(kLHintsTop

TGLayoutHints *fLH_C = new TGLayoutHints( kLHintsCenter

TGLayoutHints *fLH_L = new TGLayoutHints( kLHintsLeft ,

TGLayoutHints *fLH_R = new TGLayoutHints( kLHintsRight

//????????? Menu ??????????

                                                                                           TGMenuBar *fMB = new TGMenuBar( this , X, Y);// ,              kHoriz

AddFrame(fMB, fLH_TX);

TGPopupMenu *fM=fMB?>AddPopup("&Menu1"); fM?>AddEntry("&Fenetre " ,M_1); fM?>AddSeparator ( ) ; fM?>AddEntry("O&ption 2" ,M_2) ; fM?>Associate ( this );

TGPopupMenu *fM2=fMB?>AddPopup("&Menu2"); fM2?>AddEntry("&Option 1" ,M_3) ; fM2?>AddSeparator ( ) ; fM2?>AddEntry("O&ption 2" ,M_4) ; fM2?>Associate ( this );

                                                                               //????????? zone        superieure

                                                                             auto                               * fFrame1 = new TGHorizontalFrame( this , X, Y);/

                                                                                AddFrame(fFrame1 ,          fLH_L);

TGButton            *fOkButton = new TGTextButton(fFrame1 , "&O fOkButton?>Associate ( this ); fFrame1?>AddFrame(fOkButton , fLH_L);

                                         //..      bouton 2

                                                                              TGButton                          *fOkButton2 = new TGTextButton(fFrame1 , "&

fOkButton2?>Associate ( this ); fOkButton2?>Move(50 ,50); fFrame1?>AddFrame(fOkButton2 , fLH_L);

//????? Tab ??????????????????

TGTab *fTab = new TGTab( this , X,Y);

AddFrame(fTab );

                                                                               //..     Tab1        ???????????

TGCompositeFrame * tf1 = fTab?>AddTab("Tab 1");

                                                                               //..      bouton      1

TGTextButton * fB1 = new TGTextButton( tf1 , "&Bouton fB1?>Associate ( this );

tf1?>AddFrame(fB1 );

                                                                               //..      bouton      2

TGTextButton * fB2 = new TGTextButton( tf1 , "&Bouton fB2?>Associate ( this ); tf1?>AddFrame(fB2 );

                                                                               //..     Tab2       . . . . . . . . . . . . . . . . . .

TGCompositeFrame * tf2 = fTab?>AddTab("Tab 2");

MapSubwindows ( ) ;

Resize ( ) ;

MapWindow( ) ;

                                                                                SetWindowName(" Fenetre         de commandes ");       // nom de      la f

}

//===========================

                           ~Com()     //       destructeur

{

}

//=====================================

                            Bool_t          ProcessMessage (Long_t msg ,           Long_t p1 ,        Long_t p2)

{

int M = GET_MSG(msg) , S=GET_SUBMSG(msg ); cout<<"Fen : M = "<<M<<" S = "<<S<<" p1="<<p1<<"

p2="<<p2<<endl ;

i f (M==1 && S==1 && p1 ==M_1 && p2== 0) new Fen2( fClient ?>GetRoot () , this , 400 , 200);

return kTRUE;

}

};      //     fin    de    la     classe

/*!===Main================================================

*/

int        main( int      argc ,     char     **argv )

{

                                    TApplication theApp("App" ,             nullptr ,         nullptr );

                           Com *com=       new Com( ) ;     //    cree      fenetre     de     control      et      l ’ associe      a

l ’ objet present theApp .Run( ) ; //????donne la main a l ’ u t i l i s a t e u r ???

                return     0;

}

16.7.3      Construire une interface de widgets       la souris avec GuiBuilder

Root propose un logiciel pour construire le code            la souris : GuiBuilder. Cela permet au moins de voir la syntaxe du code pour rØaliser une construction. Voici comment l’utiliser.

16.8         Autres trucs

16.8.0.1 Nombre alØatoire avec Root Voir TRandom.

#include <TRandom.h>

gRandom->SetSeed(0); // initialise le hasard sur l’horloge double x= gRandom->Uniform(2); // nombre alØatoire dans l’intervalle (0,2)

16.8.0.2           Quelques Options gØnØrales de Root avec

#include <TROOT.h>

Mode Batch (sans sortie Øcran + rapide et permet de le lancer sur un serveur.) :

gROOT->SetBatch(kTRUE); // met en mode Batch gROOT->IsBatch(); // permet de savoir si on est en mode batch.

gROOT->SetStyle("Plain"); // style standard Rendre les dessins Øditables (modi ables) :

gPad->SetEditable(0); // rend les dessins non modifiables gPad->SetEditable(1); // rend les dessins modifiables

TCanvas *c=h->GetCanvas(); //Pour obtenir la fenetre TCanvas partir d’un histogramme TH1 *h

gStyle->SetPadGridX(kTRUE); // grilles en X,Y gStyle->SetPadGridY(kTRUE);

Chapitre 17

Mesure du temps

On prØsente ici la classe chrono.

Mais on peut aussi conseiller la classe

17.1           Mesure de la date et du temps ØcoulØ

17.1.0.1           Mesure tr?s prØcise du temps :

#include <chrono> using namespace std::chrono; #include <iostream> using namespace std;

int main() { auto t1=high_resolution_clock::now(); // mesure du "time point 1"

// . instruction qui prend du temps ..

for(int i=0;i<1e5;i++) cout<<" \t"<<i<<flush; // .

auto t2=high_resolution_clock::now(); // mesure du "time point 2"

auto dt1=duration_cast<nanoseconds>(t2-t1).count(); // calcul de

la durØe en ns auto dt2=duration_cast<milliseconds>(t2-t1).count(); // calcul de la durØe en ms

163

CHAPITRE 17. MESURE DU TEMPS                                                                                            164

cout<<"durØe: "<<dt1<< "ns"<<" = "<<dt2<< "ms"<<" = "<<dt3<<" s."<<endl; }

A    che :

0 1 2 3 99996 99997 99998 99999 durØe: 491264417ns = 491ms = 0.491264 s.

17.1.0.2       A       chage de la date

Au programme prØcØdent, si on rajoute :

auto tt=system_clock::to_time_t(t1); // convertit au type time_t cout << "Maintenant c’est: " << ctime(&tt); On obtient :

Maintenant c’est: Mon Aug 25 19:37:30 2014

17.2       Attendre

17.2.1           Attendre une certaine durØe

#include <thread> #include <chrono> using namespace std::chrono; using namespace std::this_thread;

sleep_for(seconds{2}); // attend 2 secondes sleep_for(milliseconds{3}); // attend 3 millisecondes

17.2.2         Attendre jusqu’          une certaine date

#include <iostream>

#include <thread> #include <chrono> using namespace std::chrono; using namespace std::this_thread; using namespace std;

CHAPITRE 17. MESURE DU TEMPS                                                                                            165

main () {

auto t1 = high_resolution_clock::now(); // date actuelle cout<<" J’attends 3 secondes"<<endl; auto t2 = t1 + seconds {3}; // date future

sleep_until(t2); // attente

auto t3 = high_resolution_clock::now(); // date mesurØe auto dt = duration_cast<duration<double>>(t3-t1).count(); // mesure

dt = t3-t1 cout<<"La durØe a ØtØ dt = "<<dt<<" s."<<endl; } On obtient :

J’attends 3 secondes

La durØe a ØtØ dt = 3.00016 s.

Chapitre 18

IntØgrer des Øquations di Ørentielles

ordinaires (EDO) avec la librairie

ODEINT

On propose d’utiliser la librairie odeint de boost. Voir aussi la documentation

oø X (t) ? Rⁿ est un vecteur qui dØpend du temps t ? R, et F : Rⁿ × R ? Rⁿ est une fonction connue. On connait X (0) et F l’on cherche X (t) pour d’autres valeurs de t ? R. Le thØor?me de Cauchy Lipchitz garantit l’existence et l’unicitØ de X (t) mais on a rarement une expression explicite de la solution. L’ordinateur est utile pour trouver des valeurs approchØes de X (t).

Exemple          Pour intØgrer avec la methode runge_kutta_dopri5 with standard error bounds

10-6 for the steps , le champ de vecteur dans X (t) = (x₀ (t),x₁ (t),x₂ (t)) ? R³ du syst?me de Lorenz dØ ni par :

avec les param?tres : ? = 10, R = 28, b = 8./3., on Øcrit :

#include <iostream>

#include <> #include <>

166

using namespace std;

using namespace boost::numeric::odeint;

const double sigma = 10.0; const double R = 28.0;

const double b = 8.0 / 3.0;

const int N=3; //nbre de variables de l’EDO

                    /// - definition de la fonction                intØgrer

void lorenz( const array<double,N> &x , array<double,N> &dxdt , double t

)

{

dxdt[0] = sigma * ( x[1] - x[0] ); dxdt[1] = R * x[0] - x[1] - x[0] * x[2];

dxdt[2] = -b * x[2] + x[0] * x[1];

}

/// int main()

{

array<double,N> x = { 10.0 , 1.0 , 1.0 }; // conditions initiales

double t1 =0 ,t2=25; // temps initial et final double dt =0.1; //pas de temps for(double t=t1; t<=t2; t=t+dt)

{

integrate( lorenz , x , t, t+dt, dt); // intØgre entre t et t+dt

cout << t << ’\t’ << x[0] << ’\t’ << x[1] << ’\t’ << x[2] << endl;

}

}

Remarque 18.0.1. Pour plus d’options ou autres mØthodes d’intØgration voir la documentation.

Exercice 18.0.2. Modi er le code ci-dessus pour dessiner la trajectoire dans le plan x₁,x₂ avec un point tous les pas de temps dt = 0.02 et t = 0 ? 100 et obtenir l’image suivante :

#include <iostream>

#include <boost/array . hpp>

#include <boost/numeric/odeint . hpp>

#include <TApplication .h>

#include <TCanvas .h>

#include <TMarker .h>

#include <TH1F.h>

using       namespace     std ;

using       namespace        boost : : numeric : : odeint ;

const double sigma = 10.0; const double R = 28.0; const double b = 8.0 / 3.0; const int N=3; //nbre de variables de l ’EDO

///? definition de la fonction intØgrer void lorenz ( const array<double ,N> &x , array<double ,N> &dxdt , double t )

{

dxdt [ 0 ] = sigma * ( x [ 1 ] ? x [ 0 ] ); dxdt [ 1 ] = R * x [ 0 ] ? x [ 1 ] ? x [ 0 ] * x [ 2 ] ;

                     dxdt [ 2 ] = ?b * x [ 2 ] + x [ 0 ]          * x [ 1 ] ;

}

/// int           main ()

{

                       TApplication theApp("App" ,             nullptr ,         nullptr );

                               TCanvas *c = new TCanvas( "c " ," fenetre " ,500 ,500);                  // on      precise      la t a i l l e

double xmin(?30),ymin (0) ,xmax(30) ,ymax(50);

TH1F *h=c?>DrawFrame(xmin , ymin ,xmax,ymax );   //         coordonnees   de        la         fenetre  ( h?>SetXTitle ("x1 "); h?>SetYTitle ("x2 "); int          cpt=0;

array<double ,N> x = { 10.0 , 1.0 , 1.0 }; // conditions i n i t i a l e s double t1 =0 , t2=100; // temps i n i t i a l et f i n a l double dt =0.002; //pas de temps

                for ( double      t=t1 ;      t<=t2 ;      t=t+dt )

{

integrate ( lorenz , x , t , t+dt , dt ); // integre entre t et t+dt // cout << t << ’\t ’ << x [ 0 ] << ’\t ’ << x [ 1 ] << ’\t ’ << x [ 2 ] << endl cpt++;

TMarker p2(x [1] , x [ 2 ] , 8 ) ; p2 . SetMarkerColor (kRed ); p2 . SetMarkerSize (2); p2 .Draw ( ) ;

i f ( cpt%10==0) c?>Update ( ) ;

}

c?>Update ( ) ; theApp .Run( ) ;

}

Chapitre 19

Lecture et Øcriture d’un  chier son (audio) de format WAV

19.0.0.1 Introduction Un signal audio est une fonction t ? R ? s(t) ? R qui reprØsente les variations de pression sonores en fonction du temps t.

Un chier audio au format WAV reprØsente le signal audio pour des valeurs discr?tes du temps :

t_j = j.?t,         j = 1,2,

avec un pas de temps ?t^?1 appelØe frØquence d’Øchantillonage. Les valeurs standard sont : ?t^?1 = 8000Hz, ?t^?1 = 44100Hz, ?t^?1 = 48000Hz, etc. Chaque valeur s(t_j) est codØe sur 8 bits ou 16 bits. Le nombre de caneaux 1 ou 2 indique si le chier peut contient un (mode mono) ou deux signaux (mode stØrØo). Le chier WAV contient les valeurs s(t_j) la suite, mais au dØbut du chier il y a les param?tres du codage. Regarder le code source pour plus d’informations.

19.0.0.2              Travail prØalable pour le projet C++

1.    Fichiers            tØlØcharger et sauver dans son rØpertoire : bib_fred.h et .

2.    Dans codeblocks, il faut ajouter ces chiers au projet en faisant dans le menu : Projet/add_ les

3.    Il faut aussi rajouter -larmadillo dans les options de compilation (pour codeblocks c’est dans Setting/Compiler/LinkerSettings/OtherLinkerOptions)

19.0.1           Programme pour Øcrire un            chier WAV :

Pour tester, tØlØcharger ce chier et sauvegarder le dans le rØpertoire de votre projet.

Le programme suivant permet

171

                 de lire et a       cher les param?tres du codage audio de ce         chier sonore s(t_j) ? R

(nombre de canaux, taux d’echantillonage etc..), de mettre les amplitudes s(t_j) dans un vecteur de nombres de dessiner ce vecteur avec la librairie ROOT.

#include <iostream> using namespace std; #include <TCanvas.h>

#include <TMarker.h>

#include <TApplication.h>

#include ""

///-------------------------------------------int main()

{

TApplication theApp("App", nullptr, nullptr);

//---- lecture audio du fichier wav avec le logiciel vlc system("vlc ");

//--- lecture de tout le fichier

vec signal;

double f=Lecture_fichier_wav("", signal);

// transfert les donnØes du fichier dans le vecteur double dt=1./f; // pas en temps

//Dessin(signal, "signal");

Dessin(signal,"s","s",0,()*dt,"signal",0,"L",-1e4,1e4,kBlue,0);

//--- lecture d’une partie vec signal2;

double t1=4, t2=4.03; // intervalle de temps en secondes f=Lecture_fichier_wav("", signal2, 1,t1,t2); dt=1./f;

//Dessin(signal2, "s2");

Dessin(signal2,"s","s",t1,()*dt,"signal2",0,"L",-1e4,1e4,kRed,0);

(); }

Sortie du programme :

Remarquer que vous pouvez zoomer le dessin etc Sortie du programme sur le terminal :

=====CrØe tableau           partir du fichier: ChunkID=RIFF format=WAVE

Nombre de canaux=1

Frequence d’echantillonage=48000 Hz

Bits par echantillon=16

Nombre de donnØes =834402 Nombre d’octets par echantillon=2 Pas de temps dt =2.08333e-05 s.

DurØe T =8.69169 s.

Lecture fichier finie.

--------------------

19.0.2           Programme pour lire un            chier WAV :

Le programme suivant crØe un signal ØchantillonØ dans un vecteur de double (de type vec) et ensuite Øcrit ce vecteur dans un chier au format WAV. De plus il lance le logiciel vlc qui permet de jouer le chier (envoie sur la carte son).

#include <iostream> using namespace std; #include <TCanvas.h>

#include <TMarker.h>

#include <TApplication.h>

#include ""

///-------------------------------------------int main()

{

TApplication theApp("App", nullptr, nullptr); double dt=1./48000; // pas de temps en s. double T=5;// durØe en s.

double f0=440; // frequence de la note que l’on veut en Hz

for(int i=0; i<N; i++)

{ double t=i*dt;

double f= f0 *(1+0.01*cos(2.*M_PI*t/1.)); // modulation de frequences double s= sin( 2*M_PI * f * t ); // note pure de frequence f s = s + 0.5 * sin( 2*M_PI * 2*f * t ); // rajoute harmonique 2 s = s + 0.3 * sin( 2*M_PI * 3*f * t ); // rajoute harmonique 3 signal(i) = s;

}

Dessin(signal,"s","s",0,()*dt,"signal",0,"L",-4,4,kBlue,0);

// ecrit le vecteur signal dans le fichier . On indique dt

Ecriture_fichier_wav(signal, dt,"");

//---- lecture audio du fichier wav avec le logiciel vlc system("vlc ");

(); }

Sortie du programme : ce       chier l’image du signal et la sortie sur terminal : =====CrØe un fichier wav      partir du tableau

Nombre de canaux=1

Frequence d’echantillonage=48000 Hz

Bits par echantillon=16

Nombre d’octets par echantillon=2 Nombre d’ echantillons =240000 Pas de temps dt =2.08333e-05 s.

DurØe T =5 s.

Chapitre 20

Gestion de la carte son (audio temps rØel) avec la librairie sndio

On utilisera la librairie dØveloppØe pour OpenBSD mais utilisable aussi avec Cette librairie permet de gØrer le son audio et aussi les Øv?nements midi en temps rØel (entrØe/sortie).

Remarques

Pour avoir la liste des cartes sons faire cat /proc/asound/cards ou aplay -l, cela donne par exemple

0    [HDMI ] : HDA-Intel - HDA Intel HDMI HDA Intel HDMI at 0xf7a1c000 irq 38

1    [PCH ] : HDA-Intel - HDA Intel PCH HDA Intel PCH at 0xf7a18000 irq 37

20.1         Installation (          faire la premi?re fois)

Si vous Œtes administrateur, suivre cette Puis tester :

Pour envoyer (Øcouter) le chier sur la carte 0 (carte son par default) par exemple il faut Øcrire : aucat -i .

Si il n’y a pas de son et le message snd0: rsnd/0: failed to open audio device c’est que la carte son 0 n’existe pas. VØri er la liste des cartes sons de votre ordi avec la commande aplay -l et :

Øcrire : aucat -f rsnd/1 -i .

Si la carte 1 est la carte son par defaut (au lieu de la carte 0) il faut Øditer

/etc/default/sndiod et ajouter l’option DAEMON_OPTS="-f rsnd/1". Voir remarques de con guration ci-dessous pour plus d’options.

176

Sinon si vous n’Œtes pas administrateur et que cette librairie n’est pas dØj installØe, il vous faut l’installer sur votre compte. Pour cela :

TØlØcharger le source et dØcompresser l’archive. Dans le rØpertoire de sndio ainsi crØØ, taper :

configure --prefix=$HOME make make install

Remarque : cela a pour e et de compiler la biblioth?que et d’installer les librairies dans HOME/lib et HOME/include.

Dans les options de compilation, il faudra rajouter :

-I/$HOME/include ( : dans codeblocks, c’est       rajouter dans Settings/Compiler/CompilerSetting/OtherOptions),

-L/$HOME/lib et -lsndio ( : dans codeblocks, c’est          rajouter dans Settings/Compiler/LinkerSettings/OtherOptions)

Dans le chier .bashrc il faut rajouter export LD_LIBRARY_PATH=$HOME/lib et executer dans une fenŒtre de commande : . .bashrc

Autres options de con guration de sndio : Dans le chier /etc/default/sndio on peut ecrire par exemple :

DAEMON_OPTS="-z 128 -q rmidi/0 -q rmidi/1 -q rmidi/2 -f rsnd/1 -s default

-m play,mon -s fred" puis faire

service sndiod enable service sndiod start

Rappel : amidi -l : enumere les ports midi utilises par les appareils" aplay -l : detecte les cartes son -> numero 1" Ces options signi ent :

-q : signi e con gurer & exposer ce port midi pour que plusieurs programmes puissent l’utiliser"

-z latence

-f rsnd/1 : demande utiliser carte son numero 1. L’ordre est important. plus d’info avec : xterm -e sudo pasuspender -- SNDIO_DEBUG=2 etc..

-m play,mon -s fred : signi e redirige la sortie audio vers l’entree. Cela permet d’enregistrer ce qui est jouØ. Il y a une association entre les connecteurs entree et en sortie.

20.1.0.1              Travail prØalable pour le projet C++

1.    Fichiers tØlØcharger et sauver dans son rØpertoire : bib_fred.h et , audio.h et

2.    Dans codeblocks, il faut ajouter ces chiers au projet en faisant dans le menu : Projet/add_ les

3.    Il faut aussi rajouter -larmadillo dans les options de compilation (pour codeblocks c’est dans Setting/Compiler/LinkerSettings/OtherLinkerOptions)

4.    DØmarrage du serveur sndiod, si vous Œtes administrateur, Øcrire dans un terminal :

sudo sndiod -dd -z480 -f rsnd/0 et le laisser ouvert, sinon, si sndio a ØtØ installØ sur votre compte, Øcrire dans un terminal : sndiod -dd -z480 -f rsnd/0 et le laisser ouvert.

20.2      Utilisation du micro (entrØe) et du haut-parleur (sortie)

20.2.1         Le micro

Le micro Øchantillonne le son avec un pas de temps Dt = 1/48000sec. et envoie les donnØes la carte son qui les convertit sous forme numØrique. Cet exemple lit les donnØes du micro depuis la carte son par bloc de N = 1000 donnØe, soit de durØe T = N.Dt = 0.02sec., et les dessine au fur et mesure.

#include ""

#include "" #include <iostream> using namespace std;

#include <TROOT.h>

#include <TApplication.h>

//===Main================================================ int main()

{

TApplication theApp("App", nullptr, nullptr);

Audio s;

s.Initialise_audio(1); // initialise la carte son en entree (1)

et affiche ses informations int N=1000; // on donne la taille que l’on veut (nombre d’echantillons) vec V(N);

while(1) // boucle infinie

{

s.Lit_donnees_audio(V); // remplit V depuis le micro

Dessin(V,"V");

// Dessin(V,"t","s",0,N*s.Dt,"V",0,"L",-1e4,1e4,kRed,0); // dessin normalisØ en rouge

}

/// ----Donne la main a l’utilisateur ();

}

20.2.1.1               Exemple : dØtection de note de musique en temps rØel

Periode : T=0.0034036s. <-> Frequence f=1/T=293.806 Hz Note =Re, Ecart = 0.00833494 demitons, Octave=0.

#include            "bib_fred . cc"

#include          "audio . cc"

#include <iostream> using namespace std ;

#include <TROOT.h>

#include <TApplication .h> string Notes [12] = {"Do" ,"Do#", "Re" ,"Re#", "Mi" , "Fa" , "Fa#", "Sol " , "Sol#",

//===Main================================================

int       main ()

{

                       TApplication theApp("App" ,             nullptr ,         nullptr );

Audio s ;

                        s . Initialise_audio (1);           //    i n i t i a l i s e    la     carte      son en      entree     (1)     et    affich

                       int N=2000; // on donne          la    t a i l l e    que     l ’ on veut       ( determine      la      fenetre tem

vec V(N);

//parametres pour la detection de la periode int NP=2; // 1 ,2: nbre de periodes afficher double f_A = 440; // diapason s . seuil_norme_par_I=1e4 ;

                s . seuil_C       =0.1;

                s . verbose       =0; //1        affiche       messages      erreur

//????????????????????? while (1)         //         boucle i n f i n i e

{

//??? conversion en note de musique double nu = 12* log ( f /f_A)/ log (2.) + 69;

                                        int           nu_i = floor (nu+0.5);

cout<<" Note ="<<Notes [ nu_i%12]<<" Ecart = "<<nu?nu_i<<" demitons

//???? affiche NP periodes extraites vec Extrait = V. rows ( t0/s .Dt , ( t0+NP*T)/ s .Dt ); // on extrait NP

                                       uword          i = Extrait . index_max ( ) ;

Extrait =s h i f t ( Extrait , ?i ); // place le max de l ’ extraitau debu Dessin ( Extrait ," t " ," s " ,0 ,NP*T," Extrait " ,0 ,"L",?1111,?1111,kRed , 0 )

}

}

/// ????Donne          la         main a l ’ u t i l i s a t e u r ??? theApp .Run( ) ;

}

20.2.2          Le haut-parleur

Voici un exemple qui lit les donnØes sur le micro et les envoie sur le haut-parleur apr?s un dØlai de 200ms ( la latence ). Mettre un casque.

#include            "bib_fred . cc"

#include          "audio . cc"

#include <iostream> using namespace std ;

#include <TROOT.h>

#include <TApplication .h>

int       main ()

{

                       TApplication theApp("App" ,             nullptr ,         nullptr );

Audio s ;

s . Initialise_audio (3); // i n i t i a l i s e la carte son en entree et sortie (3 vec V;

                while (1)     //     boucle    i n f i n i e

{

                                 s . Lit_donnees_audio (V);             // micro ?> V

                                          Dessin (V," t " ," s " ,0 ,V. size ()* s .Dt,"V" ,0 ,"L",?1e4 ,1 e4 , kRed , 0 ) ;                //   dessin

                                  s . Ecrit_donnees_audio (V);                // V ?> Haut Parleur

}

/// ????Donne          la         main a l ’ u t i l i s a t e u r ??? theApp .Run( ) ;

}

Chapitre 21

Plusieurs programmes en parall?le qui communiquent, avec thread

Il peut Œtre utile dans un projet de rØpartir le travail entre plusieurs programmes qui fonctionnent ensemble et communiquent. Un ordinateur est capable de gØrer plusieurs programmes qui fonctionnent. Si l’ordinateur ne poss?de qu’un processeur, il va faire avancer chaque programme tour tour en alternant sur des intervalles de temps tr?s court. Cela donne l’impression que plusieurs programmes fonctionnent en parall?le. On va s’interesser la communication entre ces programmes.

On peut imaginer cela comme des travailleurs qui fabriquent une maison. Chacun travaille sur sa partie mais il y a des moments oø ils doivent Øchanger des informations, parfois un travailleur doit attendre qu’un autre ait ni son travail. Alors c’est le chef de projet (le processeur) qui se charge de superviser tout cela, de mettre en attente certains et rØactiver d’autres.

Il y a donc trois concepts importants dont nous allons voir la mise en oeuvre :

1.    Les threads : au niveau de la terminologie, chaque programme s’appelle un thread ou process ou context . On va tout d’abord apprendre dØmarrer des threads.

2.    Les mutex : lorsque ces programmes doivent communiquer c’est dire Øchanger des donnØes (et c’est souvent le cas) il y a des prØcautions prendre a n que tout ce passe bien : par exemple il faut Øviter qu’une variable soit manipulØe par deux threads en mŒme temps. Ce sera le r le des mutex qui sont simplement des indicateurs booleen (vrai/faux) que l’on interpr?te comme (occupØ/libre).

rØfØrences : article sur C++11 threads, locks and condition variables.

183

21.1           Lancement de threads ou processus

#include <iostream> // std::cout using namespace std; #include <thread>

//---- Une petite fonction qui affiche des   a ---------------void f(int n)

{

for(int i=0;i<n;i++) cout<<"a"<<flush;

cout<<endl; }

//----Fonction principale ---------------int main()

{ // ici la fonction main est lancØe

int n=10;

thread t(f,n); // lance la fonction f(n) dans un thread

cout << "Les fonctions main et f sont maintenant en concurrence.\n"; for(int i=0;i<n;i++) // affiche des    b cout<<"b"<<flush;

cout<<endl;

t.join(); // attend ici que la fonction f soit finie cout << "f est finie.\n";

}

21.1.0.1            Commande de compilation :

Si on utilise codeblocks, il faut rajouter -pthread -std=c++11 dans Settings/Compiler/Compiler_Settings/Other_Options et dans Settings/Compiler/Linker_Settings/Other_linker Pour une compilation en ligne de commande :

g++ -o -pthread -std=c++11

RØsultat :

Les fonctions main et f sont maintenant en concurrence.

bbbbbaaaaaaaaaabbbbb f est finie.

21.1.0.2         Commentaires

1.    Les fonctions f et main fonctionnent en parall?le et leur a chages ’a’ ou ’b’ sur l’Øcran se mØlangent de fa on incontrollØe. Un deuxi?me lancement du programme donnerait Øventuellement autre chose.

2.    On peut passer (ou pas) des variables           la fonction lancØe en parall?le, ici on passe la variable n.

(a)   On peut passer un pointeur (adresse d’une variable) la fonction f en Øcrivant par exemple, void f(int * pn) {..} pour la dØclaration et thread t(f,&n); pour le lancement.. Cela permet de transmettre un rØsultat de la fonction f vers la fonction main.

3.    Il peut Œtre utile de crØer une certaine attente dans un programme. Utiliser Section

17.2.

4.    Si vous oubliez t.join() la         n, il y aura une erreur l’execution du programme.

5.    Documentation compl?te sur

21.1.0.3               Lancer un thread d’une fonction membre de classe

#include <iostream> using namespace std; #include <thread>

class A

{ public:

void f(int n ) { cout << n << endl; }

};

int main()

{ A a;

thread t1(&A::f, &a, 100); ();

}

Commentaires

Si on lance le thread depuis une autre fonction membre, il faut bien sßr remplacer le pointeur &a par this.

21.1.0.4             Lancer une liste de thread (tableau)

#include <iostream> // std::cout using namespace std;

#include <thread>

//---- Une petite fonction qui affiche n fois n ---------------void f(int n)

{ for(int i=0; i<n; i++) cout<<n<<flush;

}

//----Fonction principale ---------------int main() { int n=7;

thread L_t[n]; // tableau de threads

for (int i=0; i<n; i++)

L_t[i] = thread(f,i); // lance de thread i qui affiche i fois i for(int i=0; i<n; i++)

L_t[i].join(); // attend ici que le thread i soit fini }

RØsultat :       315524563656666254443

21.1.0.5             Lancer une liste de thread (vector)

MŒme chose que prØcØdement mais avec un vector.

#include <iostream> // std::cout using namespace std;

#include <thread>

//---- Une petite fonction qui affiche n fois n ---------------void f(int n)

{ for(int i=0; i<n; i++) cout<<n<<flush;

}

//----Fonction principale ---------------int main()

{

int n=7; vector<thread> L_t; // tableau de threads

for (int i=0; i<n; i++)

L_t.push_back(thread(f,i)); // lance de thread i qui affiche i fois i for(int i=0; i<n; i++)

L_t[i].join(); // attend ici que le thread i soit fini }

21.2           Mutex pour annoncer occupØ/libre

21.2.0.1         Introduction

Un mutex est simplement une variable boolØenne dont on pense que la valeur est occupØ/libre . Une analogie possible est qu’un mutex est comme le panneau devant une salle de bain (sans serrure) qui annonce une valeur occupØ/libre . Par exemple, on peut utiliser un mutex avant de modi er une variable commune plusieurs threads. On dØclare un mutex par

mutex mtx;

Ensuite il y a deux commandes de base :

1.    La commande ();

                     qui signi e : si mtx est libre       on le met      occupØ     et on continue, sinon, si il est

                    occupØ alors on attend jusqu’      ce qu’il soit libre.

2.    La commande mtx.unlock(); qui signi e : on met mtx libre

21.2.0.2 Remarques Quel intØret d’utiliser un mutex mtx plutot qu’une variable boolenne mtx ordinaire pour e ectuer la suite d’instructions si mtx est libre on le met occupØ et on continue, sinon on attend?

rØponse : en utilisant une variable ordinaire, il y a le risque qu’un autre processus viennent modi er la valeur de la variable pendant cette suite d’instructions, ce que l’on ne souhaite absolument utilisant un mutex il est garantit que cette suite d’instruction est faite tout la suite par l’ordinateur, sans Œtre interrompu (on dit de fa on atomique ).

21.2.0.3        Exemple

#include <iostream> // std::cout using namespace std; #include <thread> #include <mutex> mutex mtx;

//-------------------void f(int n,char c)

{

(); // si mtx est libre on le bloque, sinon on attend

for(int i=0;i<n;i++)

cout<<c<<flush;

cout<<endl;

mtx.unlock(); // dØbloque mtx

}

//-------------------int main() { int n=10; thread t1(f,n,’a’); thread t2(f,n,’b’);

(); (); }

21.2.0.4        RØsultat :

aaaaaaaaaa bbbbbbbbbb

21.3 Communications : variables conditionnelles pour rØveiller un programme en attente

Introduction Dans la communication entre programmes (process), il peut arriver qu’un programme 2 attende le resultat d’un autre(s) programme(s) 1.

Voici une solution naive et maladroite pour programmer cette solution :

Il y a une variable qui est a=0 au dØpart et que le programme met la valeur a=1 d?s qu’il a obtenu sont rØsultat. (Cette variable est protØgØe par un mutex). Le programme 2 e ectue une boucle in nie dans laquelle il lit la variable a et si a==1 alors il sort de la boucle et rØcup?re le rØsultat. Cette solution est maladroite car le programme 2 consomme du CPU (processeur de la machine) pour rien.

Une meilleure solution est que le programme 2 soit mis en attente (en veille, il ne consomme pas de CPU) et rØveillØ l’arrivØe du rØsultat. Pour cela on utilise une variable conditionelle.

Instructions de base : Une variable conditionnelle se dØclare par condition_variable cv; Il y a la commande (lck);

qui met le thread en attente (endormi), et cv.notify_one();

qui reveille un parmi les autres thread qui se sont mis en attente, (ou cv.notify_all();

qui reveille tous les autres thread qui se sont mis en attente.)

21.3.0.1                  Exemple de base oø un thread endormi est reveillØ par un autre.

#include <iostream> using namespace std; #include <thread>

#include <chrono>

#include <mutex>

#include <condition_variable>

mutex mtx; condition_variable cv;

//-------------------void f() {

unique_lock<mutex> lck(mtx); // bloque le mutex mtx. Il sera debloque automatiquement par wait(lck), ou a la destruction de lck.

(lck); // met le thread en attente (endormi). Il sera rØveillØ

par un signal extØrieur. cout<<"FIN"<<endl; }

//-------------------int main() { thread t(f);

// reveille cv

cv.notify_one(); // reveille le thread endormi

//

t.join(); }

RØsultat :

On attend 2sec. voil . FIN

21.3.0.2        Remarques

L’instruction wait() sauvegarde tous les registres du processus (tout son environnement mØmoire) et notify_one() les restore.

dans cet exemple l’utilisation du mutex ne sert rien, mais le langage C++ oblige l’utiliser dans l’instruction wait(lck). Voir ci-dessous l’exemple 21.3.4 oø l’utilisation du mutex est utile et obligatoire. Pourquoi faut il utiliser le mutex mtx? L’utilisation d’un mutex est obligatoire, car les thread se partagent une variable cv qui spØci e l’Øtat sommeil/reveillØ et donner l’instruction de rØveil. La fonction wait() utilise cette variable en faisant en fait de fa on sØquentielle : lecture de cv, si signal je dois me rØveiller.

Exemple 21.3.1. oø un thread endormi attend des Øv?nements provenant de di erents thread extØrieurs .

#include <iostream> using namespace std; #include <thread>

#include <chrono>

#include <mutex>

#include <condition_variable>

mutex mtx;

condition_variable cv;

// void f1()

{ while(1)

{ this_thread::sleep_for(chrono::milliseconds {1000}); cout<<"1"<<flush;

cv.notify_one(); // reveille le thread main() endormi }

}

// void f2() { while(1)

{

this_thread::sleep_for(chrono::milliseconds {1502}); cout<<"2"<<flush;

cv.notify_one(); // reveille les thread main() endormi

}

}

// int main() { thread t1(f1); thread t2(f2);

unique_lock<mutex> lck(mtx); // bloque le mutex mtx. Il sera debloque

automatiquement par wait(lck), ou a la destruction de lck.

while(1)

{

(lck); // met le thread main() en sommeil

cout<<","<<flush; }

// (); ();

}

RØsultat :        1,2,1,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,1,2,

Remarque 21.3.2.

1,2,1,1,2,1,2,1,1,2,..

Plusieurs threads peuvent Œtre mis en attente par (lck); et la commande cv.notify_one(); va en reveillØ un seul (on ne sait pas lequel). Par contre la commande cv.notify_all(); reveillerait tous les threads mis en attente.

Exemple 21.3.3. oø deux thread endormi sont reveillØs par une noti cation venant d’un 3eme thread .

#include <iostream> using namespace std; #include <thread>

#include <chrono>

#include <mutex>

#include <condition_variable>

mutex mtx;

condition_variable cv;

// void f1() {

unique_lock<mutex> lck(mtx); // bloque le mutex mtx. Il sera debloque

automatiquement par wait(lck), ou a la destruction de lck.

cout<<"a"<<endl; (lck); cout<<"b"<<endl;

}

// void f2() {

unique_lock<mutex> lck(mtx); // bloque le mutex mtx. Il sera debloque

automatiquement par wait(lck), ou a la destruction de lck.

cout<<"A"<<endl; (lck); cout<<"B"<<endl;

}

//

int main()

{ thread t1(f1); thread t2(f2);

                                 for(int t=3; t>=0; t--) // compte               rebour

{

this_thread::sleep_for(chrono::seconds {1});

cout<<t<<","<<flush; // \r permet de re-ecrire au debut de la ligne

}

cout<<"partez!"<<endl; cv.notify_all();

// (); (); }

Exemple 21.3.4. Un thread remplit une liste. Le deuxieme thread vide la liste .

#include <iostream> using namespace std ;

#include <thread> #include <chrono>

#include <mutex>

#include <condition_variable>

#include <list > mutex mtx;

condition_variable               cv ;

list <int> L; int N=10;

//???????????????????? void            f ()

{

                while (1)     //     boucle    i n f i n i e

{

{

} //            i c i       lck        est       detruit donc mtx est   debloque mtx. lock ( ) ;

cout<<"Liste         pleine . On vide           la         l i s t e  par       le         debut:"<<flush ; while (L. size ()>0)

{

cout<<L. front()<<","<<flush ; this_thread : : sleep_for ( chrono : : milliseconds           {100});

                                          L. pop_front ( ) ;       //     enleve     le     premier      element

} cout<<endl ;

mtx. unlock ( ) ;

                              cv . notify_one ( ) ;       //    r e v e i l l e    le     thread      endormi

}

}

//???????????????????? int           main ()

{

               thread      t ( f );     //     lance     la      fonction      f       dans un thread

                while (1)     //     boucle    i n f i n i e

{

                            mtx. lock ( ) ;      //     bloque     le    mutex

                                  i f (L. size ()==0) //          si    l i s t e     vide

{

                                           cout<<"Liste        Vide .      Remplit     la       l i s t e :"<<flush ;

                                         for ( int         j =0; j< N;        j++)

{ cout<<j <<","<<flush ; L. push_back( j ); this_thread : : sleep_for ( chrono : : milliseconds {100});

} cout<<endl ;

}

                              cv . notify_one ( ) ;       //    r e v e i l l e    le     thread      endormi

//                se met en attente unique_lock<mutex> lck (mtx ); cv . wait ( lck );

}

/ / . . . . . . . . .

t . join ( ) ; return  0;

}

RØsultat :

Liste Vide. Remplit la liste:0,1,2,3,4,5,6,7,8,9,

Liste pleine. On vide la liste par le debut:0,1,2,3,4,5,6,7,8,9,

Liste Vide. Remplit la liste:0,1,2,3,4,5,6,7,8,9,

CHAPITRE 21. PLUSIEURS PROGRAMMES EN PARALL¨LE QUI COMMUNIQUENT, AVEC THRE

Liste pleine. On vide la liste par le debut:0,1,2,3,4,5,6,7,8,9,

Chapitre 22

Messages MIDI Musical temps rØel avec la librairie sndio

La convention sur les messages MIDI (Musical Instrument Digital Interface) entre ordinateurs sont apparus dans les annØes 80 pour la musique Ølectronique, l’informatique musicale et les synthØtiseurs. RØfØrence sur les messages MIDI.

Dans ce chapitre nous voyons comment envoyer et/ou recevoir des messages midi depuis un programme en utilisant la librairie sndio. On verra aussi comment utiliser ces messages midi en musique.

Con guration prØalable

22.1         Installation (          faire la premi?re fois)

Suivre les instructions de la Section 20.1.

De plus il faut tØlØcharger les chiers suivants et les sauver dans son rØpertoire : et .

1.    Si vous utilisez codeblocks, il faut ajouter ces chiers au projet en faisant dans le menu : Projet/add_ les

2.    Si vous utilisez un Make le, rajouter les   chiers au projet selon les explications de la Section 14.

3.    Il faut aussi rajouter -lsndio dans les options de compilation (pour codeblocks c’est dans Setting/Compiler/LinkerSettings/OtherLinkerOptions)

22.2 Exemple ØlØmentaire sur l’envoi et reception de messages MIDI

196

un contenu tr?s particulier qui ont une signi cation musicale comme dØbut de telle note , changement de volume ,.., et dans la Section suivante on prØcisera comment utiliser ces messages pour l’informatique musicale (reception des notes d’un clavier numØrique et envoie de notes un synthØtiseur).

Instructions

Copier et compiler les programmes et avec le programme Make le donnØs ci-dessous.

Lancer le programme test_midi_in dans un terminal puis le programme test_midi_out dans un autre terminal.

RØsultat :

Le programme test_midi_in se met en attente et lorsqu’il recoit un message midi (provenant du programme test_midi_out) il l’a        che      l’Øcran :

port ouvert.

Attente de message ..

1 messages recus.

Message recu sur le port=0: 144, 60, 50 Midi::On ferme les ports midi..

                    Le programme test_midi_out a       che :

port ouvert.

J’ai envoye le message 144, 60, 50 sur le port 0 Midi::On ferme les ports midi..

Code C++ des programmes : Voici le code C++ ainsi que le Make le permet de compiler les deux programmes par l’instruction make all.

//===== Programme test_midi_in . cc ========== #include <iostream>

using   namespace      std ; #include            "midi . h"

int       main ()

{

Midi midi ;

//??? ouvre un port midi en entree int port=0; // numero de port

                            int                           res = midi . Initialise_port_midi_in ( port );

i f ( res==0) cout<<"port est       encore ferme."<<endl ;

else cout<<"port  ouvert."<<endl ;

//??? attente      de        messages cout<<"Attente     de message .."<<endl ;

midi . Attente_Message ( ) ; cout<<"Messages    recus."<<endl ;

}

//===== Programme test_midi_out . cc ========== #include <iostream>

using  namespace      std ; #include            "midi . h"

int       main ()

{

Midi midi ;

//??? ouvre port midi out int port = 0;

                            int      res =                 midi . Initialise_port_midi_out ( port );

i f ( res==0)

{

                                                       cout<<"port      est     encore       ferme."<<endl ;

exit (1);

} else cout<<"port            ouvert."<<endl ;

                              //???? envoie       message :     144 ,    60 ,   50

vector<unsigned char> message ; message . push_back (144); message . push_back (60);

//?? ferme        les        ports    midi     ouverts midi . Ferme_port_midi_out( port );

}

#=== Fichier              Makefile

LIBR= ?lm               ?lpthread ?lsndio             ?std=c++11

CC =g++           ?std=c++11

#========================================== OBJETS_MIDI_O=            test_midi_out . o midi . o

midi . o      :     midi . cc     midi . h

                               $(CC) $(CFLAGS)         ?c       $ *. cc ?o [email protected]

test_midi_out . o : test_midi_out . cc bib_fred . h $(CC) $(CFLAGS) ?c $ *. cc ?o [email protected]

test_midi_out :                 $(OBJETS_MIDI_O)

                            $(CC)          ?o test_midi_out             $(OBJETS_MIDI_O)             $(LIBR)

#========================================== OBJETS_MIDI_I= test_midi_in . o midi . o

midi . o      :     midi . cc     midi . h

                               $(CC) $(CFLAGS)         ?c       $ *. cc ?o [email protected]

test_midi_in . o : test_midi_in . cc bib_fred . h $(CC) $(CFLAGS) ?c $ *. cc ?o [email protected]

test_midi_in :                  $(OBJETS_MIDI_I)

                            $(CC)           ?o test_midi_in              $(OBJETS_MIDI_I)              $(LIBR)

#========================== a l l           :           test_midi_out  test_midi_in

22.3            Exemple d’envoie de message MIDI             un synthØti-

seur

Le numØro de la note do est 60, ensuite do# = 61, etc Voir messages midi.

Travail prØalable

Installer un synthØtiseur MIDI comme midisyn et le lancer. Il sera alors l’Øcoute du port midithru/0 qui est le port 0 dans notre programme. Par exemple on lance midisyn dans une fenetre de commande part, par l’instruction : midisyn

Brancher un piano Ølectrique ou autre instrument midi sur l’ordinateur, et observer le numØro de port par l’instruction amidi -l dans un terminal. Cela donne le numØro de port mettre dans le programme suivant d’apr?s la liste dans le chier midi.h. Par exemple rmidi/2 (port 2 de l’instruction amidi -l) est sur le port 4. Lancer le programme suivant qui va jouer la gamme chromatique.

//===== Programme gamme. cc ========== #include <iostream>

using  namespace      std ; #include            "midi . h"

int       main ()

{

Midi midi ;

//??? ouvre port midi out int port = 0;

                            int      res =                 midi . Initialise_port_midi_out ( port );

i f ( res==0)

{

                                                       cout<<"port      est     encore       ferme."<<endl ;

exit (1);

} else

                                                       cout<<"port          ouvert."<<endl ;

/ / . . . . .

int ch = 0; // canal int inst = 0; // instrument , 0: piano

                                midi . Program_Change( port ,        ch ,       inst );//        associe        l ’ instrument       inst     au                                                c

{

/ / . . . . . . .    joue     une note          midi     . . . . . . . . . . int         vol       =100;

cout<<"joue note "<<key<<endl ; midi . Joue_note( port , ch , key , vol ); // message pour jouer une midi . Sleep (200); // attente en ms

/ / . . . . eteind une note midi . . . . . . . . . midi . Eteind_note ( port , ch , key ); // message pour eteindre la

}

//?? ferme        les        ports    midi     ouverts midi . Ferme_port_midi_out( port );

}

#====== Fichier                     Makefile====================================

OBJETS_MIDI_G=            gamme. o midi . o

midi . o      :     midi . cc     midi . h

                               $(CC) $(CFLAGS)         ?c       $ *. cc ?o [email protected]

gamme. o     : gamme. cc

                               $(CC) $(CFLAGS)         ?c       $ *. cc ?o [email protected]

gamme:         $(OBJETS_MIDI_G)

                            $(CC)       ?o gamme         $(OBJETS_MIDI_G)             $(LIBR)

Remarque 22.3.1. La liste des codes des instruments est donnØe d’apr?s la convention general midi . Le canal 9 est rØservØ aux percussions. Mais si vous utilisez le synthetiseur midisyn, pour le moment il n’y a que les possibilitØs suivantes :

Le dØtail des sons est con gurable dans les   chiers etc On peut par exemple rajouter de nouveaux sons en ajoutant les chiers raw correspondant et un chier de con guration associØ.

//===== Programme gamme. cc ========== #include <iostream>

using  namespace      std ; #include            "midi . h"

int       main ()

{

Midi midi ;

//??? ouvre port midi out int port = 0;

                            int      res =                 midi . Initialise_port_midi_out ( port );

i f ( res==0)

{

                                                       cout<<"port      est     encore       ferme."<<endl ;

exit (1);

} else

                                                       cout<<"port          ouvert."<<endl ;

/ / . . . . .

int ch = 0; // canal int inst = 0; // instrument , 0: piano

                                midi . Program_Change( port ,        ch ,       inst );//        associe        l ’ instrument       inst     au                                                c

                             for ( int               key=60; key<=72; key++) //montee de                 la gamme chromatique

{

                                                     / / . . . . . . .        joue     une note      midi      . . . . . . . . . .

                                                     int     vol     =100;

cout<<"joue note "<<key<<endl ; midi . Joue_note( port , ch , key , vol );

                                                        midi . Sleep (200);       //      attente      en ms

/ / . . . stick midi . Joue_note( port , 9 , 37 , vol ); midi . Sleep (200); // attente en ms

/ / . . . . eteind une note midi . . . . . . . . . midi . Eteind_note ( port , ch , key );

}

/ / . . . splash midi . Joue_note( port , 9 , 55 , 100);

//?? ferme        les        ports    midi     ouverts midi . Ferme_port_midi_out( port );

}

22.4             Reception de notes midi depuis un piano Ølectrique

Comme application de l’exemple prØcØdent, le programme suivant ecoute les messages midi et les analyse. Si il reconnait Note on et Note o , il a che les notes identi Øes.

Travail prØalable

Brancher un piano Ølectrique ou autre instrument midi sur l’ordinateur, et observer le numØro de port par l’instruction amidi -l dans un terminal. Cela donne le numØro de port mettre dans le programme suivant d’apr?s la liste dans le chier midi.h. Par exemple rmidi/2 (port 2 de l’instruction amidi -l) est sur le port 4.

//===== Programme reception_notes . cc ========== #include <iostream> using namespace std ;

#include          "midi . h"

int       main ()

{

Midi midi ;

//??? ouvre un port midi en entree int port=0; // numero de port

                            int                           res = midi . Initialise_port_midi_in ( port );

i f ( res==0) cout<<"port est       encore ferme."<<endl ;

else cout<<"port  ouvert."<<endl ;

//??? attente      de        messages midi . Attente_Message ( ) ;

//???analyse       des       messages        recus for ( auto message          :           midi . L_message)

octet .        I l     reste     le    message     midi      standard

i f ((( int ) message [0])/16 == 0x9 && (( int ) message [ 2 ] ) > 0 ) // note on avec vel >0

{ int             ch=(int ) message [0] ?0x90 ; int   key=(int ) message [ 1 ] ; int   vel=(int ) message [ 2 ] ;

                                                                                cout<<"Note on       recue    :                port="<<port_in<<" canal="<<ch

}

else   i f ((( int ) message[0])/16==0x8         | |        ((( int ) message [0])/1 //        note           off

{ int             ch=(int ) message [ 0 ] ;

i f (ch/16==0x8) ch?= 0x80 ; else i f (ch/16==0x9)

ch?= 0x90 ;

int          key=(int ) message [ 1 ] ; int          vel=(int ) message [ 2 ] ;

                                                                               cout<<"Note      off     recue    :                port="<<port_in<<" canal="<<c

}

}

//??? ferme   port     midi midi . Ferme_port_midi_in( port );

}

#========================================== OBJETS_MIDI_R=            reception_notes . o midi . o

midi . o      :     midi . cc     midi . h

                               $(CC) $(CFLAGS)         ?c       $ *. cc ?o [email protected]

reception_notes . o            :        reception_notes . cc

                               $(CC) $(CFLAGS)         ?c       $ *. cc ?o [email protected]

reception_notes :                  $(OBJETS_MIDI_R)

#========================== a l l           :           reception_notes

Chapitre 23

Messages MIDI (Musique) sur             chier

Les messages musicaux MIDI peuvent Œtre Øcrit dans un chier. Ce format s’appelle Standard Midi File S.M.F. ref : ici ou ici ou la rØfØrence.

La convention des messages est tr?s similaire aux messages en temps rØel. Il y a peu de di Ørences (il y a Message mØta Øv?nement et plus de Message temps rØel )

23.1        Structure d’un         chier SMF

Il est constituØ de blocs de donnØes appelØs chunk (=gros morceau). Le premier bloc annonce les suivants.

Conventions sur le codage des nombres :

CLF Codage longueur xe . Un nombre entier positif X est codØ sur n octets x₁x_n avec x_j ? [0,255] au format big-endian, c’est dire que le nombre associØ X est

X = x1256n?1 + x2256n?2 + xn?1256 + xn Sauf mention du contraire on utilise CLF.

CLV Codage longueur variable : pour n octets x₁,x₂, x_n on utilise seulement les 7 derniers bits de chaque octet. Le premier bit quand lui est 1 (et donc octet x_j ? 128) pour les octets 0 ? j < n, et pour le dernier octet utilisØ j = n le premier bit est 0 (et donc octet x_n < 128). Le nombre associØ X est (format big-endian)

X = x˜₁128 + x˜_n?1128 + x_n,          avec x˜_j = x_j ? 128

23.1.1            Premier bloc (header chunk)

Il est composØ de

4 octets : MThd = 0x4D546864. Ces 4 caract?res invariables en dØbut de chier signalent que c’est un chier MIDI.

207

L : 4 octets : 0x00000006 : longueur invariable en octets de ce bloc, comptØe apr?s ces 4 octets.

C : 2 octets :

0x0000 : si le chier contient un seul bloc apr?s celui ci. Il contiendra Øventuellement plusieurs canaux (pour avoir polyphonie)

0x0001 : (le plus courant) si le     chier contient plusieurs blocs apr?s celui ci. Ils seront jouØs simultanØment. (polyphonie). Les mØtadonnØes sont sur le premier bloc.

N : 2 octets : nombre de blocs qui vont suivre ce premier bloc.

F : 2 octets : Delta time ou unitØ de temps .

Si le premier bit de F est 0, cad F < 2¹⁵ = 32768, alors l’unitØ de temps est

oø T qui est le tempo cad la durØe entre deux pulsation. ex :  est Andante donnØe apr?s dans les mØta donnØes (ou pas donnØe). En gØnØral,

F = 120,240,480,960

Si le premier bit de F est 1, cad F ? 2¹⁵ = 32768, alors F est codØ en SMPTE compatible units. Midi time code cad

F = (100bbbbb   cccccccc)_base2

avec (bbbbb)_base2 est le nombre d’images par secondes (ex : 24,25,29,30) et

(cccccccc)_base2est le nombre de subdivisions d’une image ( frame )

23.1.2            Bloc de piste (Track chunk)

Il est composØ de

4 octets : MTrk = 0x4D54726B

L    : 4 octets : longueur en octets de ce bloc. (comptØs apr?s ces 4 octets) Une suite d’ Øv?nements midi (Midi event). Chaque Øv?nement midi est composØ de

N_t : nombre de pas de temps ?t ØcoulØs depuis l’Øv?nement prØcØdant, codØ au format CLV.

M  : Un message midi (le nombre d’octets dØpend du premier quartet) : Si le premier quartet q (4 bits) a le premier bit 1, cad q ? 8 alors M a 2 ou 3 octets.

Si le premier quartet q (4 bits) a le premier bit 0, cad q < 8 alors M a deux octets, c’est dire que la derni?re action est rØpØtØe, meme 1er octet, running status . Par exemple pour coder l’accord C-E-G sur le canal 3

(x00 - x93 - x3C - x40) (x00 - x93 - x40 - x40) (x00 - x93 - x43 - x40) : sans running status

ou (x00 - x93 - x3C - x40) (x00 - x40 - x40) (x00 - x43 - x40) : avec running status

La n de bloc est annoncØe par le message avec 3 octets: xFF, x2F, x00

23.1.3           Message Midi standard M

M a 2 ou 3 octets M = x₁,x₂,x₃. Le premier octet est dØcomposØ en 2 quartet (4 bits

chacuns)

x₁ = qc

oøc ? [0,15] est le numØro de canal. Les octets suivants sont

0 ? x₁,x₂< 128

23.1.4 Message mØta Øv?nement M (pour les signaux midi sur chier et non pas temps rØel)

23.1.5           Message du syst?me (System Exclusive Message (SysEx)) M

Le message se termine par le mŒme octet 0xF7 :

0xF0 + <data_bytes> 0xF7 ou: 0xF7 + <data_bytes> 0xF7

23.1.6      Message temps rØel M (pour les signaux midi temps rØel et non sur    chier)

23.1.7               Control Change pour les message x₁ = xBc

(copiØ de jchr)

Selon la valeur de x₂= type :   x00 Bank Select : sØlection d’une banque de sons x01 Modulation Wheel : roulette de modulation (  0 si rØinitialisation)

x02 Breath Controller : contr le par le sou            e x04 Foot Controller : contr le au pied x05 Portamento Time : rapiditØ du portamento x06 Data Entry MSB : octet fort de donnØe supplØmentaire x07 Channel Volume : volume principal d’un canal x08 Balance

x0A Pan : panoramique, 64 est le milieu

x0B Expression Controller : contr le de l’expression (127 si rØinitialisation) x0C E ect Control 1 : e et 1 x0D E ect Control 2 : e et 2

x10 x13 General Purpose 1-4 : contr leurs tout usage x20           x3F octet de poids faible pour les contr leurs 0-31 x40 Damper Pedal : maintient toutes les notes (0 si rØinitialisation) x41 Portamento On/O    (0 si rØinitialisation)

x42 Sostenuto On/O : sustain pour la note jouØe au moment du dØclenchement (0 si rØinitialisation)

x43 Soft Pedal On/O         : pØdale douce (0 si rØinitialisation) x44 Legato Footswitch : contr le de legato au pied x45 Hold 2 : autre sustain

x46 Sound Controller 1 / Sound Variation : variation du timbre

x47 Sound Controller 2 / Timbre/Harmonic Intens. : contenu harmonique du timbre x48 Sound Controller 3 / Release Time : temps de release par dØfaut x49 Sound Controller 4 / Attack Time : temps d’attaque x4A Sound Controller 5 / Brightness : brillance

x4B Sound Controller 6 / Decay Time : temps d’extinction du son

de param?tre non enregistrØ x63 NRPN / Non-Registered Parameter Number - MSB : octet de poids fort de numØro

de param?tre non enregistrØ x64 RPN / Registered Parameter Number - LSB : octet de poids faible de numØro de param?tre enregistrØ

x65 RPN / Registered Parameter Number - MSB : octet de poids fort de numØro de param?tre enregistrØ x78 - x00 All Sound O : Øteint tous les sons, mŒme les ns d’enveloppe x79 - x00 Reset All Controllers : rØinitialise tous les contr les

            x7A - xnn Local Control On/O             : dØsactive (x00) ou rØactive (x7F) la production du

son par le clavier ma tre x7B - x00 All Notes O : Øteint toutes les notes (mais pas les enveloppes), comme le

font les quatre suivant x7C - x00 Omni Mode O        - recommandØ explanations x7D - x00 Omni Mode On : envoie les ØvØnements sur tous les canaux x7E - xnn Mono Mode On : ne permet qu’une note   la fois sur un canal, ce qui permet de mieux simuler la production de son d’un instrument monophonique (portamento); xnn est le nombre de canaux??? x7F - x00 Poly Mode On : permet plusieurs notes simultanØes sur un mŒme canal

23.1.8            type pour les Meta-Evenement

Un meta-evenement contient

0xFF

1 octet : meta-type event : (cf cidessous)

1 octet L : length of meta event data ou en codage CLV? the actual event data.

Par exemple: 3 octets: xFF, x2F, x00 en n de bloc.

23.1.9             Systeme exclusif Messages (Sysex)

Constructeurs Ces identi ants servent lors de messages spØci ques au matØriel (SysEx, DLS and XMF). Les membres historiques du MMA disposent d’un identi ant d’un octet; les plus rØcents consistent en deux octets prØ xØs de l’octet nul. x00 (prØ xe) x0E Matthews Research x24 Hohner x46 Kamiya Studio x01 Sequential Circuits x10 Oberheim x25 Crumar x47 Akai x02 Big Briar x11 PAIA x26 Solton x48 Victor

x03 Octave / Plateau x12 Simmons x27 Jellinghaus Ms x4B Fujitsu

x04 Moog x13 DigiDesign x28 CTS x4C Sony x05 Passport Designs x14 Fairlight x29 PPG x4E Teac x06 Lexicon x15 JL Cooper x2F Elka x50 Matsushita x07 Kurzweil x16 Lowery x36 Cheetah x51 Fostex x08 Fender x17 Lin x3E Waldorf x52 Zoom x09 Gulbransen x18 Emu x40 Kawai x54 Matsushita x0A Delta Labs x1B Peavey x41 Roland x55 Suzuki x0B Sound Comp. x20 Bon Tempi x42 Korg x56 Fuji Sound x0C General Electro x21 S.I.E.L. x43 Yamaha x57 Acoustic Technical Lab.

x0D Techmar x23 SyntheAxe x44 Casio

Chapter 24

Autres librairies conseillØes (?)

Trinilos

Math Kernel Library

24.1        alg?bre linØaire

SimuNova

Eigen pour l’alg?bre linØaire.

24.2             Images, vidØos, graphisme et boites de dialogues

pour le graphisme de base (avec OpenGL) et le son audio. Librairie bien adaptØ pour les jeux.

pour les boites de dialogues et le graphisme. Biblioth?que lØg?re et performante.

biblioth?que tr?s gØnØrale, performante, multiplateformes mais assez complexe.

213

Chapitre 25

Le traitement d’images et de vidØos avec la librairie OpenCV

est spØcialisØe pour le traitement d’image et de vidØos (CV signi e ComputerVision ). Un Tutoriel. Livre conseillØ : OpenCV by example de P. Joshi, D.M. Escriva et V. Godoy.

25.1          Commande de compilation

Avant d’Øcrire un programme utilisant les librairies de OpenCV, il faut, une fois pour toutes,

Dans Settings/Compiler/Linker_Settings/Other_linker_Options, rajouter :

‘pkg?config ??cflags ??l i b s                     opencv ‘

Remarque 25.1.1. Si vous n’utilisez pas codeblocks, mais Make le par exemple, la compilation en ligne de commande du programme pour donner l’executable main est :

g++ main . cpp ?o main ?g ?std=c++11                            ‘pkg?config ??cflags ??l i b s            opencv ‘

25.2          Lecture et ecriture de          chiers images

Les commentaires expliquent les fonctions. Il faut avoir le chier dans le rØpertoire du programme.

#include <iostream> using namespace std ;

214

#include <string >

#include <opencv2/core/core . hpp>

#include <opencv2/highgui/highgui . hpp> using namespace cv ;

//========================= int           main ()

{

/ / . . . . .         Lecture d ’ un  pixel int           x=img . cols /2;            //         selectionne           point    (x , y) au          centre  de        l ’ image int     y=img . rows /2;

Vec3b p= img . at<Vec3b>(x , y ); cout << "La valeur du       pixel    en x="<<x<<", y="<<y<<" est  (B,G,R) :           (" << ( int )p

/ / . . . . .         dessin  de        l ’ image imshow("Image" , img );

}

Resultat :

A che deux images : une en couleur et l’autre en noir et blanc. Pixel value (B,G,R): (3,7,12)

25.2.0.1           Fonctions utiles sur les images Copie d’une image :

La commande Mat image2 = image1; ne fait pas une copie des images mais seulement de l’adresse (c’est dire que image1 et image2 vont dØsigner la mŒme image). Pour dupliquer l’image il faut faire image1.copyTo(image2);

Recadrage d’une image :

resize(frame, frame, Size(), scalingFactor, scalingFactor, INTER_AREA); Mat img= imread("", 0); // 0 : convertit en gris

25.3          Utilisation de la souris

Le programme suivant montre comment utiliser la souris. Dans cet exemple on selectionne une partie de l’image avec clic gauche (down/up) et on revient l’image de dØpart avec clic droit (down). Le codesuivant utilise le chier image tØlØcharger dans le mŒme rØpertoire.

#include <iostream>

using        namespace     std ;

#include <string >

#include <opencv2/core/core . hpp>

#include <opencv2/highgui/highgui . hpp> using namespace cv ;

//??????????????????????????????? Mat img , image , roi ; int etat_select = 0;// 0: selection pas faite , 1: selection en cours , 2: sele

Rect selection ; // t a i l l e de la selection Point origin ; // point de depart de la selection

//???? fonction             appelee     si     la     souris      est      actionnee

static           void onMouse(       int     event ,      int    x ,     int    y ,     int ,       void* )

{

//                             cout<<"event="<<event<<" x="<<x<<" y="<<y<<endl ;

                             //??? si         action du      c l i c     souris

                switch (      event    )

{

i f ( etat_select==0)

{ origin = Point (x , y ); selection = Rect (x , y ,0 ,0); etat_select = 1;

}

break ;

case 4: // c l i c gauche up i f ( etat_select==1 && selection . width > 0 && selection . height > 0 )

{

                                                                                 etat_select         =2; //        selection      f i n i e

                                                                                  bitwise_not ( roi ,         roi );      //      inversion      de    roi    ( dans imag

imshow("Image" ,          roi ); }

break ;

                           case    2:    // c l i c       droit down

i f ( etat_select==2)

{ etat_select = 0;

imshow("Image" , img ); }

}

//??? si deplacement souris , traitement de l ’ image i f ( etat_select == 1 )

{

selection . x = MIN(x , origin . x ); selection . y = MIN(y , origin . y ); selection . width = std : : abs (x ? origin . x ); selection . height = std : : abs (y ? origin . y ); selection &= Rect (0 , 0 , img . cols , img . rows ); // pour ne pas depasser

i f ( selection . width > 0 && selection . height > 0 )

{

img . copyTo( image );

roi = Mat(image ,           selection );      //         la         matrice           roi        est   un bitwise_not ( roi ,  roi );     //         inversion         de        roi        ( dans imag

}

}

}

//========================= int           main ()

{

/ / . . . . .        Lecture     des    images

img= imread ("M2. png ");

/ / . . . . . Affiche l ’ image a l ’ ecran namedWindow( "Image" , 1 );

setMouseCallback ( "Image" , onMouse ,                   0    );    //      associe      la      fonction     de     lecture  de

imshow("Image" , img ); waitKey (0);

}

25.4     Lecture et Øcriture d’un         chier video ou de la webcam

#include <iostream>

#include <string >

#include <sstream> using namespace std ;

#include            "opencv2/core . hpp"

#include "opencv2/highgui . hpp" using namespace cv ;

//????????????????????????????????????? int           main ()

{

               / / . . . .       ouverture du      f i c h i e r      video ou webcam

String nom = "video_pendule .mp4";   //         f i c h i e r        video VideoCapture cap ; cap . open(nom);

                  //cap . open (0);//        ouvre      la webcam.

i f (! cap . isOpened ()) //         si          erreur d ’ ouverture return ?1;

/ / . . . ouverture d ’ un           f i c h i e r    video    en      ecriture

                         String nom2= "video_pendule2 . avi ";            //    f i c h i e r    video

Size        frameSize ( static_cast<int >(cap . get (CV_CAP_PROP_FRAME_WIDTH)) ,  static_ VideoWriter  out       (nom2, CV_FOURCC( ’P’ , ’ I ’ , ’M’ , ’1 ’) ,       20 ,      frameSize ,      true ); i f          (           ! out . isOpened ()       ) return ?1;

/ / . . . . boucle i n f i n i e while ( true )

{

                                  i f (waitKey (30) >= 0)          break ;       // Montre       dessin .      Attente        de 30 ms et    arr

}

                 cap . release ( ) ;         // libere      la    memoire     allouee

}

Remarque 25.4.1. La commande waitKey(0) permettrait de faire avancer la video image par image.

25.5            DØtection d’objet par leur couleur

Voici un exemple de programme qui lit une image et selectionne les objets bleus. Pour a            cher les images intermediares, il faut dØcommenter les lignes correspondantes.

Voici une documentation sur les formats de couleurs. On utilise le format HSV (voir aussi HSV sur wikipedia) qui est proche de la perception humaine : H ? [0,1] est la teinte de la couleur, par exemple H ? [0.5,0.7] est une palette de bleus. S ? [0,1] est la saturation entre S = 0 (blanc) et S = 1 (couleur vive). V ? [0,1] est la luminositØ entre V = 0 (noir) et V = 1

Sauver l’image ci-dessous dans le rØpertoire du programme.

RØsultat du programme :

#include <iostream>using namespace std;#include <string> #include <

25.6 DØtection et suivit d’objet de couleur avec l’algorithme CamShift

Voici des informations, sur les algorithmes MeanShift et CamShift , ou sur

Le code ci-dessous est tirØ du site web de opencv.

#include               "opencv2/video/ tracking . hpp"

#include "opencv2/imgproc/imgproc . hpp" #include "opencv2/highgui/highgui . hpp"

#include <iostream> #include <ctype .h>

using namespace cv ; using namespace std ; //??????????????????????????????? Mat image ;

bool backprojMode = f a l s e ; // true : si on montre l ’ image s e u i l l e e bool showHist = f a l s e ; // true : on montre l ’ histogramme

Rect         selection ;       //    t a i l l e    de    la       selection

Point         origin ;      //     point    de     depart    de    la       selection

//???? Si         l ’ u t i l i s a t e u r      selection      un           rectangle ?> selection           et    le     flag   trackO

static           void onMouse(       int     event ,      int    x ,     int    y ,     int ,       void* )

{

              //                  cout<<"event="<<event<<" x="<<x<<" y="<<y<<endl ;

               i f (       selectObject       )

{

selection . x = MIN(x ,     origin . x ); selection . y = MIN(y ,    origin . y ); selection . width = std : : abs (x ? origin . x ); selection . height = std : : abs (y ? origin . y );

                                  selection &= Rect (0 ,         0 ,     image . cols ,       image . rows );         // pour ne pas      depas

}

                switch (      event    )

{ cout<<"event="<<event<<endl ;

case CV_EVENT_LBUTTONDOWN:      //         coin     de    depart origin = Point (x , y ); selection = Rect (x , y ,0 ,0); selectObject = true ;

break ;

case CV_EVENT_LBUTTONUP:

selectObject = f a l s e ; i f ( selection . width > 0 && selection . height > 0 ) trackObject = ?1;

break ;

}

}

//??????????????????????????????? static           void     help ()

{

                    cout << "\nThis         is       a demo that       shows mean?s h i f t      based       tracking \n"

                               "Usage :     \n"

                             "             ./ camshiftdemo \n";

                      cout << "\n\nHot keys :          \n"

                                   "\tESC ? quit        the     program\n"

                                  "\ tc ? stop       the       tracking \n"

                                   "\tb ? switch         to/from        backprojection         view\n"

                                   "\th ? show/hide         object        histogram\n"

                                  "\tp ? pause         video\n"

                              "To    i n i t i a l i z e      tracking ,        select     the     object        with mouse\n";

}

///??????????????????????????????? int           main(   int        argc ,   const    char** argv     )

{ help ( ) ;

VideoCapture cap ;

Rect trackWindow ; int hsize = 16; // pour histogramme float hranges [ ] = {0 ,180};

               const            float * phranges = hranges ;

String    videoFile= "pendule_jaune .mp4";     //         f i c h i e r        video //           cap . open( videoFile );           // ouvre           le         f i c h i e r        video cap . open (0);            // ouvre           camera

               i f (      ! cap . isOpened ()      )

{

cout << "***Could not    i n i t i a l i z e   capturing ***\ n"; return ?1;

}

namedWindow( "Histogram " , 0         ); namedWindow( "CamShift Demo" , 0     );

                          setMouseCallback ( "CamShift Demo" , onMouse ,            0    );    //      associe      la      fonction  d

/ / . . . . pose les s l i d e r s int vmin = 10 , vmax = 256 , smin = 30; createTrackbar ( "Vmin" , "CamShift Demo" , &vmin , 256 , 0 ); createTrackbar ( "Vmax" , "CamShift Demo" , &vmax, 256 , 0 ); createTrackbar ( "Smin" , "CamShift Demo" , &smin , 256 , 0 );

Mat frame , hsv , hue , mask , hist , histimg = Mat : : zeros (200 , 320 , CV_8UC3) , bool paused = f a l s e ;

//?????? boucle i n f i n i e ?????????? for ( ; ; )

{

                           i f (    ! paused    )

{

cap >> frame ;

i f ( frame . empty () ) break ;

}

                              frame . copyTo( image );          // ?> image

                           i f (    ! paused    )

{

                                           cvtColor (image ,          hsv , COLOR_BGR2HSV);       //         convertit ?> hsv

                                        i f (      trackObject      )

{

int _vmin = vmin , _vmax = vmax;

// seuillage ?> mask ( fenetre de 0 et 1) inRange (hsv , Scalar (0 , smin , MIN(_vmin,_vmax)) , Scalar (180 , 2 //imshow( "mask" , mask );

// Mix the specified channels int ch [ ] = {0 , 0};

hue . create ( hsv . size () , hsv . depth ( ) ) ; // ?> hue : nouvelle fene mixChannels(&hsv , 1 , &hue , 1 , ch , 1); // ?> copie hsv dans hu

// on traite la selection ?> histogramme i f ( trackObject < 0 )

{ cout<<"i c i"<<endl ;

// imshow( "hue" ,              hue );

//imshow( "mask" , mask );

//waitKey (0);

// Compute the histogram and normalize it ?> tableau hist calcHist(&roi , 1 , 0 , maskroi , hist , 1 , &hsize , &phranges ) normalize ( hist , hist , 0 , 255 , CV_MINMAX);

trackWindow = selection ; trackObject = 1;

histimg = Scalar : : a l l (0); int binW = histimg . cols / hsize ; Mat buf (1 , hsize , CV_8UC3); for ( int i = 0; i < hsize ; i++ )

buf . at<Vec3b>(i ) = Vec3b( saturate_cast<uchar>(i *180./

                                                                    cvtColor ( buf ,         buf , CV_HSV2BGR);

// dessin des rectangles de l ’ histogramme sur la fenetre for ( int i = 0; i < hsize ; i++ )

{ int val = saturate_cast<int >(hist . at<float >(i )* histim rectangle ( histimg , Point ( i *binW, histimg . rows ) , Point

}

}

// Compute the histogram backprojection calcBackProject(&hue , 1 , 0 , hist , backproj , &phranges ); // ?> backproj &= mask ;      //         ameliore         backproj

                                                    / / . . .      trackwindow ,            backproj ?> trackBox

                                                       RotatedRect             trackBox = CamShift ( backproj ,             trackWindow ,

TermCriteria ( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER,                            10 , 1     ) ) ;

// Check        i f         the       area     of         trackingRect    is          too          small i f ( trackWindow . area () <= 1 )

{

i f ( backprojMode ) cvtColor ( backproj , image , COLOR_GRAY2BGR );

// draw          rotated            rectangle          trackBox Point2f          rect_points [ 4 ] ; trackBox . points (     rect_points      );

RNG rng (12345);

Scalar color = Scalar ( rng . uniform (0 , 255) , rng . uniform (0 ,255 for ( int j = 0; j < 4; j++ )

                                                                  line (     image ,        rect_points [ j ] ,             rect_points [( j +1)%4],        color ,

// Draw the e l l i p s e on top of the image e l l i p s e ( image , trackBox , Scalar (0 ,0 ,255) , 3 , CV_AA );

}

}

else i f ( trackObject < 0 ) paused = f a l s e ;

// Apply the ’ negative ’ e f f e c t on the selected region of interest i f ( selectObject && selection . width > 0 && selection . height > 0 )

{

Mat roi (image ,     selection ); bitwise_not ( roi ,       roi );

}

imshow( "CamShift Demo" ,       image  ); imshow( "Histogram " ,      histimg );

                           char          c = ( char )waitKey (10);

i f ( c == 27 ) // esc . break ;

switch ( c )

{

case ’b ’ : backprojMode = ! backprojMode ;

break ;

                           case     ’c ’ :

trackObject = 0; histimg = Scalar : : a l l (0);

break ;

                           case     ’h ’ :

showHist = ! showHist ;

i f (  ! showHist       ) destroyWindow( "Histogram"           ); else

                                                          namedWindow( "Histogram " , 1         );

break ;

case ’p ’ : paused = ! paused ;

break ;

default :

;

}

}

}

Chapitre 26

Conversion d’un programme C++ en programme Java Script avec emscripten

Le langage javascript est reconnu par tous les navigateurs internet et donc les programmes Øcrits en javascript peuvent tourner sur toutes les machines (ou smartphone ou tablettes). Javascript fait partie des trois langages de base pour la programmation des pages web :

1.    HTML qui dØ nit le contenu des pages web. Reference. Voici un site qui permet de valider votre code html, ou trouver les erreurs.

2.    CSS qui spØci e le style des pages web. Tutorial. Reference.

3.    JavaScript qui permet de programmer le comportement des pages web. Tutorial. Reference.

Le logiciel emscripten permet de convertir automatiquement du code C++ en code javascript. Cela Øvite de convertir soi mŒme le code la main, ou d’Øcrire en javascript (si on ne connait pas ce langage). De plus le code covertit et compilØ peut Œtre plus rapide que du code javascript natif.

Il y a une alternative : Cheerp. Dans cet Section, on explique comment faire cela avec des exemples tr?s simples. Voici des exemples sophistiquØs : Box2d ou Bullets

Documentations :

Voici des slides.

26.1      Installation

Voir Installation avec Portable SDK.

On vØri e que l’installation est correcte par ./emcc -v

230

26.2      Conversion C++ -> Javascript

Exemple de base :            Copier le code suivant dans le       chier

#include <iostream> using namespace std; double somme(double a,double b)

{ return a+b; } int main() {

double a=2, b=3.1;

cout<<" a="<<a<<", b="<<b<<", a+b="<<a+b<<endl; }

Compilation :                  emcc -std=c++11 -O2 -o

Cela produit l’executable javascript

Execution dans un terminal : node Cela a che :

a=2, b=3.1, a+b=5.1

Pour crØer un chier html : emcc -std=c++11 -O2 -o cela crØe un chier et le script part, que l’on execute par :

26.2.1          Autres exemples

Voir /emsdk_portable/emscripten/master/tests/ Voir tutorial

26.3              Pour connecter un code C++ et une interface html

On dØcrit ici l’utilisation de Cwrap. Autre possibilitØ serait une utilisation de WebIDL (voici un exemple).

26.3.1          Exemple de base

RØsultat :         Lien :

Code C++ :             Copier le code suivant dans le       chier

#include <math.h> extern "C"

{

//------------int f1(int x)

{ return x+2;

}

//------------char* f2(char*s)

{ char *u; u = new char[3]; u[0]=s[0]; u[1]=s[1];

u[2]=’\0’; // fin de chaine return u;

}

}

Compilation : dans un terminal Øcrire : emcc -std=c++11 -O2 -o -s EXPORTED_FUNCTIONS="[’_f1’,’_f2’]" Cela produit l’executable javascript

Remarque 26.3.1. Dans cette commande on rajoute _ au nom de la fonction.

Code html :           Ecrire le code suivant dans un      chier

<!DOCTYPE html>

<html>

<body>

<p>Entrer nombre x :</p>

<input id="n">

<button type="button" onclick="F()">Submit</button>

<h3>resultat f1(x)=x+2:</h3>

<p id="zone1"></p>

<h3>resultat f2(x): 2 premiers caracteres de x sont:</h3>

<p id="zone2"></p>

<script src="/"></script>

<script> function F()

{

var x = document.getElementById("n").value; // recupere entree (string) // ..

f1 = Module.cwrap(’f1’, ’number’, [’number’]); // declaration de

la fonction qui est definie dans var y1 = f1(x);

document.getElementById("zone1").innerHTML = y1; // envoie resultat

(string)

// ..

f2 = Module.cwrap(’f2’, ’string’, [’string’]);

var y2 = f2(x);

document.getElementById("zone2").innerHTML = y2; // envoie resultat (string)

}

</script>

</body>

</html>

Attention il faut que le script soit prØsent dans le mŒme rØpertoire.

Partage du programme : Si vous posez les chiers et dans le mŒme rØpertoire sur un serveur web, alors un utilisateur extØrieur qui charge le chier pourra exØcuter votre programme.

Cela marchera depuis toute plateforme (ordinateur sous linux, windows, mac ou mŒme iphone, android etc).

Par exemple le programme prØcØdent est utilisable ici :

Remarque 26.3.2.

Dans le chier , on Øcrit f1 = Module.cwrap(’f1’, ’number’, [’number’,’number’]) pour une fonction avec deux entrØe et une sortie. En sortie : on met null si il n’y a pas de variable. array si on renvoit un tableau d’octets.

Il est important de savoir (et parfois utile) que si il y a des variables globales (ex : des tableaux etc) dans le code c++, alors leur contenu est conservØ l’appel suivant.

26.3.2             Exemple avec des Øchanges plus complexes

Dans l’exemple prØcØdent, l’interface html et le programme c++ Øchangent seulement une variable de type int ou une chaine de caract?re.

Pour Øchanger des variables diverses (provenant de forms et qui en retour peuvent modi er le contenu de la page html), on pourra tout simplement passer l’information codØe dans une unique chaine de caract?res.

26.3.2.1        Exemple

Code C++ : ( chier )

#include <math.h>

#include <sstream>

#include <string> #include <iostream> using namespace std; #include <vector>

#include <string.h>

//=======================================

// Decompose la chaine "| .. | ..|" en sous chaines des caract?res entre les ’|’ =delim vector<string> Decompose(string ligne,char delim)

{

vector<string> instructions;

while((delim)!=string::npos) // il reste une instruction

{

auto pos= (delim); string ligne2=ligne.substr(0,pos); // ..

if(()>0)

{

// cout<<" I="<<ligne<<flush; instructions.push_back(ligne);

}

return instructions;

}

//=========================

extern "C" {

const char* f(char*s)

{

//--- parse la chaine en entree: vector<string> vs=Decompose(string(s),’%’);

//--- lecture des donnees double x = stod(vs[0]); string m=vs[1];

//--- traitement double y=x+2; string m2="Salut "+m;

//----fabrique la chaine de sortie string str_out;

                             str_out = to_string(y) +          %            + m2; // on choisit le signe % pour

separer les donnØes

char * s_out = new char [str_out.length()+1];

strcpy(s_out, str_out.c_str()); return s_out;

}

}

//===========================

int main()

{

// test

char s[]="3.14%fred faure"; const char*u = f(s);

}

Compilation :

emcc -std=c++11 -O2 -o -s EXPORTED_FUNCTIONS="[’_f’]"

Code html ( chier ) :

<!DOCTYPE html>

<html>

<body>

<p>Entrer nombre x :</p>

<input type="number" id="x">

<p>Entrer Nom :</p>

<input id="m">

<button type="button" onclick="F()">Submit</button>

<script src="/"></script>

<script> function F()

{

var x = document.getElementById("x").value; var m = document.getElementById("m").value; var s = x.toString() + "%" + m.toString(); // .. f = Module.cwrap(’f’, ’string’, [’string’])

var u = f(s);

document.getElementById("zone2").innerHTML = "debug"; var tu = u.split("%"); // on choisit le signe % pour separer les donnØes document.getElementById("zone1").innerHTML = "x+2=" + tu[0]; document.getElementById("zone2").innerHTML = tu[1];

}

</script>

<h3>resultat 1</h3>

<p id="zone1"></p>

<h3>resultat 2</h3>

<p id="zone2"></p>

</body>

</html>

Execution :            firefox

Pour tester le code C++ seulement :                      Cela utilise la fonction main() de .

Compilation :

g++ -std=c++11 -O2 -o test Execution :

./test

26.4            Exemples de forms en html

Dans l’exemple 26.3.1, on utilisØ une entrØe de type button qui permet de demander une chaine de caract?res l’utilisateur et de la transfØrer au script. Cette entrØe est un cas particulier de form en html. Voici d’autres exemples.

RØsultat :         Lien :

Code html :

<!DOCTYPE html>

<html>

<body>

<h2>EntrØes</h2>

<br>

<fieldset>

<legend>Field Set (groupe):</legend>

Une entrØe texte (R1): <br>

<input id="n">

<br>

Boutons radio (R2): <br>

<form id="test">

<label><input type="radio" name="test" value="A"> A</label>

<label><input type="radio" name="test" value="B" checked> B</label>

<label><input type="radio" name="test" value="C"> C</label>

</form>

</fieldset>

<br>

Check box (R3):

<br>

<input type="checkbox" id="cb">

<br>

Slider (range) (R4):

<br>

<input type="range" id="r" name="points" min="0" max="10">

<br>

Entree nombre (R5):

<br>

<input type="number" id="nb" name="quantity" min="1" max="5">

<br>

Selection de couleur (R6):

<br>

<input type="color" id="col" name="favcolor" value="#ff0000">

<br>

Choix multiple (R7):

<br>

<select name="pays" id="pays">

<optgroup label="Europe">

<option value="france">France</option>

<option value="espagne">Espagne</option>

<option value="italie">Italie</option>

<option value="royaume-uni">Royaume-Uni</option>

</optgroup>

<optgroup label="AmØrique">

<option value="etats-unis">Etats-Unis</option>

</optgroup>

<optgroup label="Asie">

<option value="chine">Chine</option>

<option value="japon">Japon</option>

</optgroup>

</select>

<br>

Choix de fichier (R8):

<br>

<input type="file" id="sel" name="img" multiple>

<br>

Bouton (action):

<br>

<button type="button" onclick="F()">Submit</button>

<br>

<hr>

<h2>RØsultats:</h2>

<p id="zone"></p> <script> function F()

{

var x = document.getElementById("n").value; // recupere entree (string) var text1 = "R1 = "+ x;

var form = document.getElementById("test"); var text2 = " R2 =" + form.elements["test"].value; var text3 =0;

if (document.getElementById("cb").checked) text3=1;

text3 = " R3=" + text3;

var r4 = document.getElementById("r").value; var r5 = document.getElementById("nb").value;

var r6 = document.getElementById("col").value; r6 = " R6=" + r6;

var r7 = document.getElementById("pays").value; r7 = " R7=" + r7;

var r8 = document.getElementById("sel").value; r8 = " R8=" + r8; document.getElementById("zone").innerHTML = text1 + text2 + text3

+ " R4=" + r4 + " R5=" + r5 + r6 + r7 + r8; // envoie resultat (string) sur la zone var m = document.getElementById("m1"); m.setAttribute("value", r4); var m2 = document.getElementById("m2"); m2.setAttribute("value", r4);

}

</script>

<h2>Sorties</h2>

Barre de progr?s (progress) (R4):

<br>

<progress id="m1" value="2" max="10">

</progress>

<br>

Une jauge (meter) (R4):

<br>

<meter id="m2" value="2" min="0" max="10">

</meter>

<br><hr>

</body>

</html>

26.5 Appeler des fonctions js depuis c++ et des fonctions c++ depuis js

Code c++ :

// -*- mode:C++; compile-command: "emcc -std=c++11 -O2

extern "C" { void f()

{

//.. on passe du code js dans la chaine de caractere ".."

emscripten_run_script(" var y=3; document.getElementById(\"zone1\").innerHTML = y;");

// on passe du code js dans (..)

EM_ASM(

alert(’hello world!’); );

// on passe du code js dans (.. , x0 , x1 ) avec des variables qui sont recuperees par $0,$1 etc double x0=1.2, x1=4.3; EM_ASM_(

var x0= $0; var x1 = $1; document.getElementById("zone2").innerHTML

= "x0 x1 = " + x0 + x1;

, x0, x1);

}

}

Code html :

<!DOCTYPE html>

<html>

<body>

<button type="button" onclick="F()">Submit</button>

<script src="/"></script>

<script> function F()

{

f = Module.cwrap(’f’, ’string’, [’string’]) f();

}

</script>

<h3>resultat 1</h3>

<p id="zone1"></p>

<h3>resultat 2</h3>

<p id="zone2"></p>

</body>

</html> Resultat

26.6        Autres remarques

Le prØprocesseur reconnait __EMSCRIPTEN__ qui indique que emcc est le compilateur.

26.7        Graphisme

Utiliser la librairie C SDL qui est utilisable en C++ et que emscripten peut exporter. Voir exemples sur /emsdk_portable/emscripten/master/tests/ Utilisation de Root avec Javascript.

Utilisatio de Qt avec emscripten.

Librairie OpenGL qui est utilisable en C++ et que emscripten peut exporter en WebGL. Voir

26.8          Notes musicales en html5

Voir : Vex ow. ou Alphatab ou

Voir ,

Midi :

tutorial

Audio :

webaudio

26.9             Utilisation des capteurs d’un smartphone

Voir capteurs en javascript.

26.10        Utilisation de        chiers

           Supposons que dans le rØpertoire courant il y a un     chier        contenant abcd .

Code c++ :

// -*- mode:C++; compile-command: "emcc -std=c++11 -O2

-o -s EXPORTED_FUNCTIONS="[’_f’]" --preload-file "

-*-

extern "C" { void f()

{

// lecture depuis fichier ifstream g(""); string res; g>>res;

//.. affiche le contenu

string s = "document.getElementById(\"zone1\").innerHTML = \"" +

res + "\";"; emscripten_run_script(s.c_str());

}

}

Commande de compilation emcc -std=c++11 -O2 -o -s EXPORTED_FUNCTIONS= --preload-file Code html :

<!DOCTYPE html>

<html>

<body>

<button type="button" onclick="F()">Submit</button>

<script src="/"></script>

<script> function F()

{

f = Module.cwrap(’f’)

f();

}

</script>

<p id="zone1"></p>

</body>

</html>

Chapitre 27

CrØation automatique de Make le et d’interface graphique utilisateur (GUI)

Dans ce chapitre, je prØsente un logiciel que j’ai dØveloppØ pour usage personnel au dØpart. Il Øcrit automatiquement :

                Un       chier Make le pour un projet c++

Du code c++ correspondant    des fenŒtres de commandes GUI, utilisant la librairie root.

Cela est tr?s utile lorsque on dØveloppe un projet, et permet de gagner du temps.

27.1        Mode d’emploi

ce programme sert a creer un      chier make le automatiquement. en partant d’un     chier "" qui contient le main().

Pour l’utiliser, il faut

1.    Øcrire le          chier g

2.    lancer : makef repertoire nom g <nom_executable>

3.    ensuite pour compiler (lancer le Make le), il il faut faire : make clean (pour detruire les chiers .o precedants) make all voir par exemple le script "compp"

27.1.0.1        Fonctionnement         nal des commandes

Une fenetre de commande GUI est lancØe dans un autre thread (process) "com" et utilise root. Cette fenetre de commande contient tous les widgets des variables (demandees) des classes que utilise le projet main(). Communication :

245

Si un widget est activØ (changØ), le process "com" change les variables du main avec une protection prealable de type mutex. depuis le process "main", on appelle explicitement p_com->Met_a_jour() pour que l’a chage de "com" corresponde aux variables de "main". optionnellement, le process "com" appelle Met_a_jour() de facon periodique (tous les 0.1 sec), pour eviter cet appel explicite.

Dans le programme "main", avant/apres d’acceder aux variables partagees, il faut mettre/ enlever le mutex mtx : (); mtx.unlock();

-si besoin, on a acces aux fenetres de commandes par le pointeur Com *p_com;

27.1.0.2 sortie du programme makef chiers c++ : , com.h dans le meme repertoire que chier.h qui sont des classes

c++ d’un panneau de commandes

27.1.1             Instructions pour placer les widgets

La fenetre de commande peut contenir les zones suivantes :

un menu, une zone commune : ZC des zones de tabs : ZT1, ZT2,

Les widgets sont placØs       la suite horizontalement dans la zone demandee.

Retour la ligne : On peut revenir la ligne si on commence par l’instruction "nl" : ex : double x1=4; // make_gui = nl N(ZT("tab1"), "x1=") Texte d’aide : On peut rajouter un texte d’aide (qui sera un Tip ) : ex : double x1=4; // make_gui = N(ZT("tab1"), "x1=") help = texte d’aide N : Numerique entre/sortie pour int, double ex :

int a; // make_gui = N(ZC,"a=")

double x1=4; // make_gui = N(ZT("tab1"), "x1=") T : Texte entre/sortie pour string ex : string text = "hello"; //make_gui = T(ZT("tab1")) HS : Horizontal Slider entre/sortie pour int/double ex : double x = 1; // make_gui = HS(ZT("tab1"), 0, 5)

VS : Vertical Slider : entre/sortie pour int/double PB : Progress Bar : sortie pour int,double ex :

double y = 5; // make_gui = PB(ZT("tab2"), 0,5)

CHAPITRE 27. CR ATION AUTOMATIQUE DE MAKEFILE ET D’INTERFACE GRAPHIQUE UTILI

projet : - H1 : Histogramme 1D pour pour vector<int>, vector<double>, vec

les valeurs de ces widgets sont en permanence couplØes        la variable c++.

Pour cela il y a un pointeur pour chaque classe. ex : pointeur p_C1 pour la classe C1 dans la fonction main(), il faut rajouter (avec la typo) :

#includ "com.h"

Com *com= new Com(&c1,&c2);

//thread t(Lance_com, &c1, &c2); // lance fenetre de commande dans autre thread. Donne pointeurs sur objets

On met une typo car cela ne doit pas empecher le fonctionnement de chier.h sans les commandes

(on doit pouvoir desactiver en option la compilation de , com.h) et les  chiers existants ne doivent pas etre modi Øs.

Chapitre 28

A propos des licences

Lire licences GPL.

Le tØmoignage d’un programmeur : Avec la licence tu donnes legalement le droit aux gens de utiliser le soft; sinon, ils ont juste le droit de le tØlØcharger. Donc il faut toujours une licence.

Elle doit Œtre dans l’entŒte de chaque chier. Si le texte de la license est trop long, dans l’entŒte du chier on met juste un paragraphe type indiquant comment obtenir la license; alors celui-ci est mis la racine dans un chier COPYING ou LICENSE.

Fais bien attention ne rien altØrer (meme pas les espace et les allØs la ligne), sinon on ne peut plus utiliser des outils (grep et di ) pour savoir quelle est la license; et surtout on se demandera pourquoi le texte a ØtØ altØrØ.

Pour que le soft soit libre, en pratique il faut trouver un texte de license existant, connu et ØprouvØ. Sinon l’utilisateur ne sait pas exactement quel droits il a (au sens juridique) et doit payer un avocat si il veut Œtre sur. Donc en pratique c’est comme si il n’y avait pas de license pour le commun des mortels.

Pour de l’open-source & libre il y a 2 types de licences :

2.    GNU public license (et autres semblables peu connus). Dans ce cas l’auteur demande des choses l’utilisateur, typiquement de ne pas revendre le soft et publier les modifs qu’il y fait, etc. Le texte est en consØquence assez long et ibitable. Mais des juristes s’y sont dØj penchØs et "il est bon".

On trouve aussi des license de grands industriels, typiquement 30 pages de charabia de juriste que personne ne comprend; elles sont probablement piegØs.

On trouve aussi des licences que des gens ont Øcrit en toute naivetØ et qui n’ont pas de valeur (ie un bon avocat pourrait leur faire dire tout et son contraire).

Perso, j’attends rien en retour, donc j’utilise la license ISC pour toute publication.

248

Bibliographie

249