PDF - Js Viewer

Option complémentaire d’informatique
Lycée Blaise Cendrars
8 novembre 2023
Contexte de l’Option Complémentaire
1 Genève : Logiciels libres.


Vaud : MacOS©.

Vaud : MacOS©.
Neuchâtel : Windows©.

Vaud : MacOS©.
2 Crise économique
mondiale et cantonale ⇒
Crédits zéro en 2010.

Vaud : MacOS©.
2 Crise économique
Crédits zéro en 2010.
3 Compétences présentes en
informatiques au lycée :
linux et macOS©.

Vaud : MacOS©.
2 Crise économique
Crédits zéro en 2010. ⇔
linux et macOS©.
4 Contexte éducatif et
coopératif.

Choix : logiciels libres
Vaud : MacOS©.
Neuchâtel : Windows©. 1 Système d’exploitation : Linux.
2 Crise économique
linux et macOS©.
coopératif.

Vaud : MacOS©.
2 Crise économique 2 Distribution : Debian ou LinuxMint.
linux et macOS©.
coopératif.

Vaud : MacOS©.
3 Machines : machines de
récupération ou machines montées
3 Compétences présentes en par l’école d’ingénieurs.
linux et macOS©.
coopératif.

Vaud : MacOS©.
3 Machines : machines de
récupération ou machines montées
3 Compétences présentes en par l’école d’ingénieurs.
4 Libre accès : sans risque légaux
linux et macOS©.
(piratage), utilisables sur toutes les
4 Contexte éducatif et plates-formes.
coopératif.
Systèmes d’exploitations
OS : operating system
Ce qui fait fonctionner l’ordinateur ; interface entre le matériel et l’utilisateur.
Systèmes d’exploitations
OS : operating system
Ce qui fait fonctionner l’ordinateur ; interface entre le matériel et l’utilisateur.
Principaux OS
Windows MacOS© Linux

Installé par défaut Installé par défaut De type Unix
ou acheté en pack sur machine Apple installable « partout »
Payant Payant Gratuit
Systèmes d’exploitation propriétaires
Mac OS©
Originalité : Concepteur d’ordinateur
(hardware) et de système d’exploitation
(software).
Depuis Mac OS X, système de type UNIX
très proche de Linux. Seule l’interface
graphique est propre à Macintosh.
Systèmes d’exploitation propriétaires
Mac OS©
Originalité : Concepteur d’ordinateur
Windows©
(hardware) et de système d’exploitation
(software). Système pré-installé sur la
quasi-totalité des machines disponibles
Depuis Mac OS X, système de type UNIX en magasin.
très proche de Linux. Seule l’interface
graphique est propre à Macintosh.
Licences
Licences propriétaires
Les logiciels peuvent uniquement
être utilisés.
Ils ne peuvent pas être étudiés.
Ils restent la propriété de leur
concepteurs.
Licences
Licences propriétaires Licences libres

Le code des logiciels peut être
étudié.
être utilisés.
Il peut être modié, amélioré et
réutilisé.
Le code appartient à la
concepteurs.
communauté des utilisateurs.
Licences
Licences propriétaires Licences libres

Le code des logiciels peut être
étudié.
être utilisés.
Il peut être modié, amélioré et
réutilisé.
Le code appartient à la
concepteurs.
communauté des utilisateurs.
Propriétaires ou libres, il existe beaucoup de type de licences.
Les plus connues sont la GPL (licence publique générale) et les Creatives
Commons.
Free Software Foundation (FSF), projet GNU, licences libres
Quatre libertés
Liberté 0 La liberté d’exécuter le programme - pour tous les usages
Quatre libertés
Liberté 1 La liberté d’étudier le fonctionnement du programme - ce qui
suppose l’accès au code source
Quatre libertés
Liberté 2 La liberté de redistribuer des copies - ce qui comprend la liberté de
vendre des copies
Quatre libertés
Liberté 2 La liberté de redistribuer des copies - ce qui comprend la liberté de
vendre des copies
Liberté 3 La liberté d’améliorer le programme et de publier ses améliorations -
ce qui suppose, là encore, l’accès au code source.
Libertés
1 La liberté 3 encourage la création d’une communauté de développeurs améliorant

le logiciel et permet le « fork » (exemples de Audacity et Openofce).
Libertés

2 « Libre » ne doit pas être compris comme « gratuit ». Chacun a le droit de redistribuer
gratuitement ou non un logiciel libre.
Libertés

3 Ces libertés doivent être irrévocables.
possibilité d’en jouir sans devoir prévenir un tiers
Libertés

possibilité de redistribuer le programme sous toute forme, notamment
compilée
Libertés

compilée
le code source doit être accessible pour jouir des libertés d’étude et
d’amélioration
Libertés

compilée
le code source doit être accessible pour jouir des libertés d’étude et
d’amélioration
possibilité de fusionner des logiciels libres dont on n’est pas soi-même l’auteur.
GNU-Linux
Que veut dire « GNU-Linux » ?

GNU Gnu is Not Unix. Richard Stallman crée la première licence libre.
Il n’admettait pas de disposer d’une imprimante dont le logiciel ne
fonctionnait pas, mais qu’il lui était interdit de corriger pour des
raisons de licence.
Linux Linus Torvalds crée le noyau de ce qu’il nomme Linux. Il s’agit d’un
noyau créé de tout pièces sur le modèle des systèmes d’exploitation
UNIX de l’époque.
GNU-Linux est constitué d’un noyau monolithique et d’un ensemble de logiciels
libres.
Architectures
L’ensemble des logiciels d’un ordinateur se décompose dans deux espaces :

l’espace noyau – l’espace utilisateur
Micronoyau
Noyau monolitique
Noyau des système Noyau du système Linux2 .

Windows©et MacOSX©1 .
Distributions Linux
Quelques exemples
Debian Système totalement libre : refus d’intégrer du code source sous
licence non libre.
Ubuntu Système dérivé de Debian, mais se permettant si nécessaire
d’intégrer du code non libre.
LinuxMint Dérivé de Ubuntu.
Redhat Système orienté entreprises, payant.
Fedora Basée sur Redhat, pour le particulier.
Manjaro Basée sur Fedora, fonctionne en « rolling release », c’est à dire que la
distribution est constamment mise à niveau.
OpenSuSe D’origine allemande.
Code Binaire - Code Source
Binaire
Un ordinateur ne comprend que les
zéros et uns dont est composé un
chier binaire.
0100010 1001010 01010001
10010001010000101
Code Binaire - Code Source
Source
Binaire
Un programme s’écrit dans un
Un ordinateur ne comprend que les
langage compréhensible par
zéros et uns dont est composé un
l’homme et est traduit par un
chier binaire.
compilateur en binaire.
0100010 1001010 01010001 i f ( argent = bonheur )
10010001010000101 then (1/3 p o p u l a t i o n = t r i s t e )
Logiciels
Quelques exemples
Code Perl, Python, C, . . . Astro Celestia, Kstar,

Texte LibreOfce ,
Stellarium, . . .
Scribus, Latex, . . . Web Firefox, Apache,
Textpattern, . . . Mail Thunderbird,
Image Gimp, Digikam,
Kmail, Evolution,
ImageMagik, . . . Bases MySql, . . .
...
Texte et codage
Pour coder les caractères spéciaux, on rencontre principalement 2 normes :

Caractères ⇆ Table des caractères
Norme ISO (International Organization for Standardization) Norme UTF-8 (Universal coded character set
Dérivée des 128 caractères codés de 0 à 127, soit en binaire de Transformation Format 8-bits)
0000000 à 1111111 du codage ASCII (American Standard Code for
Information Interchange). Table de codage unique : « Unicode ».
Elle sépare la représentation du caractère du codage lui-même par

Huit bit, soit un octet ; correspond à l’intermédiaire d’un index numérique nommé point de code.
l’ISO-8859-1 ou latin 1. Codage jusqu’à Celui-ci s’écrit U+nombre_hexadécimal. Les caractères
256 caractères. correspondant au latin de base se trouvent entre les points de
code 0000 et 007F, ce qui correspond en décimal à un index de 0 à
127, c’est-à-dire aux caractères ASCII.
Le latin-0 et le latin-1, ISO 8859-1 et ISO 8859-15, décrivent les
caractères de l’Europe de l’ouest, avec ou sans le caractère de
l’euro. Il s’agit de la plus utilisée sur internet !
Codage et glyphes
À un caractère correspond un seul point de code, mais peut correspondre

plusieurs glyphes (dessin particulier d’un caractère dans une certaine police).
Fontes – bézier – bitmap
Fontes vectorielles – Fontes bitmap Postscript, truetype – bdf
Courbe de bézier Représentation bitmap Anti-aliasing et hinting

Moteur de rendu de fontes
Le rendu des fontes se fait automatiquement au moment de

la frappe de chaque caractère ! ! !
Reste à créer vos propre glyphes : avec ou sans empattement – avec ou sans serif
– à taille xe ou pas...
AaBbCcFcTe AaBbCcFcTe AaBbCcFcTe

Traitements de texte
Objectifs : mettre en forme du texte. Les moyens dépendent du contexte :

Traitements de texte wysiwyg (What You See Is What You Get) (Word©,
LibreOfce, Scribus, . . .) : soulignés, gras, italique, etc.
Afches et petits documents.
Traitements de texte balisés (xhtml, LATEX, XML, . . .) :
<p align=‘‘center’’> texte </p>,
\begin{center} texte \end{center}, etc.
Internet, long documents, documentation.
LibreOfce
Traitement de texte classique. Bien que . . .
Gestion avancée des styles, références, bibliographie, index, . . .

Latex
Traitement de texte haute qualité : gestion professionnelle automatique de la

typographie.
Exemples :
« L’astrolabe, histoire théorie et pratique » et
« Loxodromie et projection de Mercator » .
Autre exemple connu : votre « formulaire et tables CRM »...

HTML et CSS
Orientation web – séparation du contenu et de la forme.
Langages balisés sans boucles, fortement normalisés et strict.

XML (eXtensible Markup Language)
Idée : structurer du contenu à l’aide de balises : < et >

Exemple : <title> Le XML (eXtensible Markup Language) </title>.
Le XML n’impose aucun contenu aux balises < >.
Chaque langage va dénir lui-même ses propres balises.
Ainsi, en HTML, on trouve la balise « title » qui peut ne pas apparaître dans un
autre langage XML.
Comment l’ordinateur comprend-il les nombres ?
Décimal
chires : 0, 1, 2, . . ., 9
nombres : 536, 2378, 24, . . .
Décimal Binaire
chires : 0, 1, 2, . . ., 9 chires : 0 et 1 (bits)
nombres : 536, 2378, 24, . . . nombres : 11011, 10, 1000, . . .
Décimal Binaire
chires : 0, 1, 2, . . ., 9 chires : 0 et 1 (bits)
nombres : 536, 2378, 24, . . . nombres : 11011, 10, 1000, . . .
Attention, 10 en binaire ne se lit pas « dix » et ne correspond pas à la valeur

décimale 10, comme nous le verrons plus tard !
Longueur d’un nombre binaire
Exercice :
« sur 1 bits »
On a 2 nombres possibles :
0 et 1
Exercice :
« sur 1 bits »
0 et 1
« sur 2 bits »
00, 01, 10 et 11
Exercice :
« sur 1 bits »
« sur 3 bits »
0 et 1
000, 001, 010, 011, 100, 101, 110 et
« sur 2 bits » 111
00, 01, 10 et 11
Exercice :
« sur 1 bits »
« sur 3 bits »
0 et 1
000, 001, 010, 011, 100, 101, 110 et
« sur 2 bits » 111
On a 4 nombres possibles : « sur 4 bits ? »
00, 01, 10 et 11
Exercice :
« sur 1 bits »
« sur 3 bits »
0 et 1
000, 001, 010, 011, 100, 101, 110 et
« sur 2 bits » 111
On a 16 nombres possibles...
00, 01, 10 et 11
Exercice :
« sur 1 bits »
« sur 3 bits »
0 et 1
000, 001, 010, 011, 100, 101, 110 et
« sur 2 bits » 111
00, 01, 10 et 11
« sur n bits ? »
Exercice :
« sur 1 bits »
« sur 3 bits »
0 et 1
000, 001, 010, 011, 100, 101, 110 et
« sur 2 bits » 111
00, 01, 10 et 11
« sur n bits ? »
On a 2n nombres possibles
Bit, byte et octet

Un octet est un nombre de 8 bits
Un octet est aussi appelé byte
Donc, on sait maintenant que l’octet permet de représenter 28 = 256 nombres, de

00000000 à 11111111.
Et le poids de tout ça ?
Décimal
kilo : nombre de possibilités de
réaliser un nombre avec 3
chires.
Décimal
kilo : nombre de possibilités de
réaliser un nombre avec 3
chires.
possibilités : 103 = 1000
Décimal Binaire
kilo : nombre de possibilités de kibi : (kilo-binaire) nombre de
réaliser un nombre avec 3 possibilités de réaliser un
chires. nombre avec 10 bits.
possibilités : 103 = 1000
Décimal Binaire
possibilités : 103 = 1000 possibilités : 210 = 1024
Décimal Binaire
En résumé
Un kilo-octet est noté Kio et correspond à 1024 octets.
Décimal Binaire
En résumé
Un mega-octet est noté Mio et correspond à 1024 Kio.
Décimal Binaire
En résumé
Un giga-octet est noté Gio et correspond à 1024 Mio.
Décimal Binaire
En résumé
Un giga-octet est noté Gio et correspond à 1024 Mio.
Un téra-octet est noté Tio et correspond à 1024 Gio.
···
Exercice :
Avec un processeur 32 bits, combien de nombres puis-je représenter ? Et avec 64
bits ?
Exercice :
bits ?
sur 32 bits, peut représenter 232 = 4294967296 (c’est beaucoup...)

Exercice :
bits ?
sur 32 bits, peut représenter 232 = 4294967296 (c’est beaucoup...)

sur 64 bits, peut représenter 264 = 1, 8 · 1019 (c’est vraiment beaucoup...)
Exercice :
Si j’écris sur une clé usb tous ces nombres (en 32 bits), quelle sera la taille du
chier obtenu en Gio ?
Exercice :
On a 4294967296 nombres possibles

Exercice :
Chaque nombre est codé sur 32 bits, donc 4294967296 · 32 = 1, 37 · 1011 bits
Exercice :
On divise par 8, donc on a 1, 71 · 1010 octets

Exercice :
On divise par 1024, donc on a 16777216 Kio

Exercice :
On divise par 1024, donc on a 16384 Mio

Exercice :
On divise par 1024, donc on a 16384 Mio
On divise par 1024, donc on a 16 Gio

Exercice :
Voici à quoi ressemblerait ce chier
00000000000000000000000000000000
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
···
11111111111111111111111111111110
11111111111111111111111111111111
Exercices :
Sur un processeur 16 bits, combien de nombres entiers non signés peut on
représenter ?
(on peut manipuler des « mots » de 16 bits, exemple 1110110000110110)
Exercices :
représenter ?
On a 216 = 65′ 536 possibilités, soit autant de nombres.
Sur le même processeur, quels sont les plus petits et plus grands nombres entiers
signés qui puissent être représentés ? (c’est à dire avec la possibilité de faire des
nombres positifs et négatifs)
Exercices :
représenter ?
On a 216 = 65′ 536 possibilités, soit autant de nombres.
Sur le même processeur, quels sont les plus petits et plus grands nombres entiers
signés qui puissent être représentés ? (c’est à dire avec la possibilité de faire des
nombres positifs et négatifs)
On a un bit de signe (0 ou 1) et 15 bits pour le nombre, soit 215 = 32′ 768
possibilités. On peut donc représenter des nombres de -32’768 à 32’767 (à cause
du zéro).
Représentation d’un nombre
Dans le système décimal, le nombre 536 est constitué de 5 centaines, 3 dizaines

et 6 unités.

et 6 unités.
Dans le système décimal
536 =

et 6 unités.
536 = 500 + 30 + 6 =

et 6 unités.
536 = 500 + 30 + 6 = 5 · 102 + 3 · 101 + 6 · 100

et 6 unités.
536 = 500 + 30 + 6 = 5 · 102 + 3 · 101 + 6 · 100
Dans le système binaire, le nombre 11011 correspond à 27 en décimal.

et 6 unités.
536 = 500 + 30 + 6 = 5 · 102 + 3 · 101 + 6 · 100
Dans le système binaire
11011 =

et 6 unités.
536 = 500 + 30 + 6 = 5 · 102 + 3 · 101 + 6 · 100
11011 = 1 · 24 + 1 · 23 + 0 · 22 + 1 · 21 + 1 · 20 =

et 6 unités.
536 = 500 + 30 + 6 = 5 · 102 + 3 · 101 + 6 · 100
11011 = 1 · 24 + 1 · 23 + 0 · 22 + 1 · 21 + 1 · 20 = 27
Exercice :
Convertir en décimal
1110110=
Exercice :
1110110=1 · 26 + 1 · 25 + 1 · 24 + 0 · 23 + 1 · 22 + 1 · 21 + 0 · 20 =
Exercice :
1110110=1 · 26 + 1 · 25 + 1 · 24 + 0 · 23 + 1 · 22 + 1 · 21 + 0 · 20 = 118
Exercice :
1110110=1 · 26 + 1 · 25 + 1 · 24 + 0 · 23 + 1 · 22 + 1 · 21 + 0 · 20 = 118
1000000=
Exercice :
1110110=1 · 26 + 1 · 25 + 1 · 24 + 0 · 23 + 1 · 22 + 1 · 21 + 0 · 20 = 118
1000000=1 · 26 + 0 · 25 + 0 · 24 + 0 · 23 + 0 · 22 + 0 · 21 + 0 · 20
Exercice :
1110110=1 · 26 + 1 · 25 + 1 · 24 + 0 · 23 + 1 · 22 + 1 · 21 + 0 · 20 = 118
1000000=1 · 26 + 0 · 25 + 0 · 24 + 0 · 23 + 0 · 22 + 0 · 21 + 0 · 20 = 64
Conversion décimal-binaire
On veut convertir 14 en binaire.

Première méthode
1 On trouve la plus grande puissance de 2 inférieure à 14 ⇒ 23 = 8

Première méthode
2 On calcule le reste, ici 14 − 8 = 6

Première méthode
3 On reprend au point 1, ⇒ 22 = 4

Première méthode
4 Le reste 6 − 4 = 2

Première méthode
4 Le reste 6 − 4 = 2

Première méthode
4 Le reste 6 − 4 = 2
6 Reste 0 !

Première méthode
4 Le reste 6 − 4 = 2
6 Reste 0 !
7 Donc, on a 14 = 1 · 23 + 1 · 22 + 1 · 21 + 0 · 20 ⇒ 1110

Deuxième méthode
1 On eectue des divisions successives par 2

Deuxième méthode
2 14/2 = 7 reste 0

Deuxième méthode
2 14/2 = 7 reste 0
3 7/2=3 reste 1

Deuxième méthode
2 14/2 = 7 reste 0
3 7/2=3 reste 1
4 3/2=1 reste 1

Deuxième méthode
2 14/2 = 7 reste 0
3 7/2=3 reste 1
4 3/2=1 reste 1
5 1/2=0 reste 1

Deuxième méthode
2 14/2 = 7 reste 0
3 7/2=3 reste 1
4 3/2=1 reste 1
5 1/2=0 reste 1
6 Donc, en inversant l’ordre d’apparition des restes : 14 = 1110
Exercice : convertir en binaire

17=

17=1 · 24 + 0 · 23 + 0 · 22 + 0 · 21 + 1 · 20 =

17=1 · 24 + 0 · 23 + 0 · 22 + 0 · 21 + 1 · 20 = 10001

17=1 · 24 + 0 · 23 + 0 · 22 + 0 · 21 + 1 · 20 = 10001
21=

17=1 · 24 + 0 · 23 + 0 · 22 + 0 · 21 + 1 · 20 = 10001
21=1 · 24 + 0 · 23 + 1 · 22 + 0 · 21 + 1 · 20

17=1 · 24 + 0 · 23 + 0 · 22 + 0 · 21 + 1 · 20 = 10001
21=1 · 24 + 0 · 23 + 1 · 22 + 0 · 21 + 1 · 20 = 10101
(dé ) 14.25=

17=1 · 24 + 0 · 23 + 0 · 22 + 0 · 21 + 1 · 20 = 10001
21=1 · 24 + 0 · 23 + 1 · 22 + 0 · 21 + 1 · 20 = 10101
(dé ) 14.25=1 · 23 + 1 · 22 + 1 · 21 + 0 · 20 + 0 · 2−1 + 1 · 2−2

17=1 · 24 + 0 · 23 + 0 · 22 + 0 · 21 + 1 · 20 = 10001
21=1 · 24 + 0 · 23 + 1 · 22 + 0 · 21 + 1 · 20 = 10101
(dé ) 14.25=1 · 23 + 1 · 22 + 1 · 21 + 0 · 20 + 0 · 2−1 + 1 · 2−2 = 1110, 01
Représentation d’un nombre en virgule ottante
En décimal
Nombre = Signe · Mantisse · BaseExposant
En décimal
Exemple : −3, 25 · 10−21 (au fait, c’est un petit ou un grand nombre ?)

En décimal
Signe : ici, négatif

Mantisse : c’est un nombre compris dans l’intervalle 1 ≤ Mantisse < 10. Ici : 3,25
Base : ici, la base est 10
Exposant : un nombre entier positif ou négatif. Ici : -21
En décimal

Exercice :
Écrire le nombre −0, 000623 en notation décimale en virgule ottante
En décimal

Exercice :
Écrire le nombre −0, 000623 en notation décimale en virgule ottante
Réponse : −0, 000623 = −6, 23 · 10−4
En binaire
En binaire
Exemple : 10000011001010000000000000000000
Signe : premier bit, 0 pour positif, 1 pour négatif. Ici, négatif

Exposant : on lui consacre les 8 suivants bits. Ici : 00000110
Mantisse : c’est un nombre compris dans l’intervalle 1 ≤ Mantisse < 2.
On lui consacre 23 derniers bits. Ici : 01010000000000000000000.
En binaire : comment faire ?

Nombre = Signe · Mantisse · BaseExposant Mais ici, attention à l’ordre !

Exemple : 10000011001010000000000000000000

Exemple : 10000011001010000000000000000000
Découpage : 1 | 00000110 | 01010000000000000000000

Signe
Exposant Mantisse
      

Exemple : 10000011001010000000000000000000
Découpage : 1 | 00000110 | 01010000000000000000000

Signe
Exposant Mantisse
      
Signe : 1 ⇒ négatif

Exemple : 10000011001010000000000000000000
Découpage : 1 | 00000110 | 01010000000000000000000

Signe
Exposant Mantisse
      
Exposant : 0 · 20 + 1 · 21 + 1 · 22 = 6.

Exemple : 10000011001010000000000000000000
Découpage : 1 | 00000110 | 01010000000000000000000

Signe
Exposant Mantisse
      
Exposant : 0 · 20 + 1 · 21 + 1 · 22 = 6. On biaise de 127 ! ⇒ 6 − 127 = −121.

Exemple : 10000011001010000000000000000000
Découpage : 1 | 00000110 | 01010000000000000000000

Signe
Exposant Mantisse
      
Mantisse : 1 + 0 · 2−1 + 1 · 2−2 + 0 · 2−3 + 1 · 2−4 =

Exemple : 10000011001010000000000000000000
Découpage : 1 | 00000110 | 01010000000000000000000

Signe
Exposant Mantisse
      
Mantisse : 1 + 0 · 2−1 + 1 · 2−2 + 0 · 2−3 + 1 · 2−4 = 1, 3125.

Exemple : 10000011001010000000000000000000
Découpage : 1 | 00000110 | 01010000000000000000000

Signe
Exposant Mantisse
      
Mantisse : 1 + 0 · 2−1 + 1 · 2−2 + 0 · 2−3 + 1 · 2−4 = 1, 3125.
Base : ici, la base est 2.
Conclusion : Le nombre est −1, 3125 · 2−121

Exemple : 10000011001010000000000000000000
Découpage : 1 | 00000110 | 01010000000000000000000

Signe
Exposant Mantisse
      
Mantisse : 1 + 0 · 2−1 + 1 · 2−2 + 0 · 2−3 + 1 · 2−4 = 1, 3125.
Base : ici, la base est 2.
Conclusion : Le nombre est −1, 3125 · 2−121 = −4, 937 · 10−37
Exercice :
Convertir le nombre binaire suivant en décimal
01000000001100000000000000000000
Exercice :
01000000001100000000000000000000
0 | 10000000 | 01100000000000000000000
Exercice :
01000000001100000000000000000000
0 | 10000000 | 01100000000000000000000
+ | 27 = 128 ⇒ 128 − 127 = 1 | 1 + 1 · 2−2 + 1 · 2−3 = 1, 375
Exercice :
01000000001100000000000000000000
0 | 10000000 | 01100000000000000000000
+ | 27 = 128 ⇒ 128 − 127 = 1 | 1 + 1 · 2−2 + 1 · 2−3 = 1, 375
Donc le nombre est 1, 375 · 21 = 2, 75
Exercice :
01000000001100000000000000000000
0 | 10000000 | 01100000000000000000000
+ | 27 = 128 ⇒ 128 − 127 = 1 | 1 + 1 · 2−2 + 1 · 2−3 = 1, 375
Exercice :
10101000001100000000000000000000
Exercice :
01000000001100000000000000000000
0 | 10000000 | 01100000000000000000000
+ | 27 = 128 ⇒ 128 − 127 = 1 | 1 + 1 · 2−2 + 1 · 2−3 = 1, 375
Exercice :
10101000001100000000000000000000
1 | 01010000 | 01010000000000000000000
Exercice :
01000000001100000000000000000000
0 | 10000000 | 01100000000000000000000
+ | 27 = 128 ⇒ 128 − 127 = 1 | 1 + 1 · 2−2 + 1 · 2−3 = 1, 375
Exercice :
10101000001100000000000000000000
1 | 01010000 | 01010000000000000000000
− | 26 + 24 = 80 ⇒ 80 − 127 = −47 | 1 + 1 · 2−2 + 1 · 2−4 = 1, 3125
Exercice :
01000000001100000000000000000000
0 | 10000000 | 01100000000000000000000
+ | 27 = 128 ⇒ 128 − 127 = 1 | 1 + 1 · 2−2 + 1 · 2−3 = 1, 375
Exercice :
10101000001100000000000000000000
1 | 01010000 | 01010000000000000000000
− | 26 + 24 = 80 ⇒ 80 − 127 = −47 | 1 + 1 · 2−2 + 1 · 2−4 = 1, 3125
Donc le nombre est 1, 3125 · 2−47 = 9, 326 · 10−15
Le plus grand nombre
Exercice : Quelle plage de nombres réels couvre la représentation d’un réel

sur 32 bits en virgule ottante (1 bit pour le signe, 8 bits pour l’exposant et 23 bits
pour la mantisse ).

pour la mantisse ).
Le nombre maximum codé par la mantisse est
−23
1+ 2i
i =−1


pour la mantisse ).
−23
1+ 2i = 1 + 2−1 + 2−2 + 2−3 · · · + 2−22 + 2−23
i =−1


pour la mantisse ).
−23
1+ 2i = 1 + 2−1 + 2−2 + 2−3 · · · + 2−22 + 2−23 = 1, 99999988079071  2
i =−1


pour la mantisse ).
−23
1+ 2i = 1 + 2−1 + 2−2 + 2−3 · · · + 2−22 + 2−23 = 1, 99999988079071  2
i =−1

7
Pour l’exposant, codé sur 8 bits, le plus grand est 2i = 255 . Pour coder les
0

négatifs on biaise de 127. Donc le nombre maximum codé pour l’exposant est
255 − 127 = 128

pour la mantisse ).
−23
1+ 2i = 1 + 2−1 + 2−2 + 2−3 · · · + 2−22 + 2−23 = 1, 99999988079071  2
i =−1

7
Pour l’exposant, codé sur 8 bits, le plus grand est 2i = 255 . Pour coder les
0

négatifs on biaise de 127. Donc le nombre maximum codé pour l’exposant est
255 − 127 = 128
Au total, on a donc la plage maximale est de 1, 9999 · 2128 = 6, 8 · 1038 , à
savoir les nombres de −3, 4 · 10−38 à +3, 4 · 10−38
Et pour calculer ?
Pour l’anecdote...
0+0=0
Et pour calculer ?
0+0=0
0+1=1
Et pour calculer ?
0+0=0
0+1=1
1+0=1
Et pour calculer ?
0+0=0
0+1=1
1+0=1
1+1=10
Et pour calculer ?
0+0=0
0+1=1
1+0=1
1+1=10
1+1+1=11
Et pour calculer ?
0+0=0
0+1=1
1+0=1
1+1=10
1+1+1=11
···
Et pour calculer ?
Pour l’anecdote... Et puis...

Après, quand on se souvient que :
0+0=0
une multiplication est une suite d’additions
0+1=1
1+0=1
1+1=10
1+1+1=11
···
Et pour calculer ?

0+0=0
0+1=1
une puissance est une suite de multiplications
1+0=1
1+1=10
1+1+1=11
···
Et pour calculer ?

0+0=0
0+1=1
1+0=1
une division est une multiplication par l’inverse
1+1=10
1+1+1=11
···
Et pour calculer ?

0+0=0
0+1=1
1+0=1
une division est une multiplication par l’inverse
1+1=10
on imagine bien qu’étant donnée que l’ordinateur
1+1+1=11 calcule très vite, et que c’est même sa seule
··· spécialité, des calculs énormes sont à notre portée.
Et pour calculer ?
Supercalculateur Frontier (USA)
Pour avoir un ordre d’idée, le supercalculateur le plus puissant actuel est le

Frontier aux USA, sous Linux, propulsé par 9472 CPU de 64 coeurs cadencés à
2GHz, il est capable d’eectuer plus d’un milliard de milliards d’opérations par
seconde !
Comment capter une image ?
première idée : « regarder au travers de la passoire... »
⇒
Comment capter une image ?
première idée : « regarder au travers de la passoire... »
Capteur CCD
Capter une image en niveaux de gris
De l’orignial à la numérisation (exemple sur 2 bits)
00 blanc
00 blanc
01 gris clair
00 blanc 10 gris foncé

01 gris clair

01 gris clair 11 noir

De l’orignial à la numérisation
Original

Original Analyse

Original Analyse Restitution


Original Analyse Restitution Numérisation
Sur huit bits, on aurait 256 niveaux de gris, mais la forme de l’image resterait
identique car elle dépend de la résolution.
Résolution d’une image
Unité : dpi (dot per inch ) ou ppp (point par pouce)
Élevée Moyenne Faible
Unités de la résolution : dpi (dot per inch) ou ppp (point par pouce).
Exemples typiques : écran 75-100 dpi, photocopieuse 360 dpi, imprimante 700
dpi, scanner 2000 dpi.
Image en couleur : codage RVB.
Idée : c’est la même que pour l’exemple

en niveaux de gris, mais le capteur
est un ltre de Bayer , composé
d’une grille de pixels ltrant les 3
couleurs de base, rouge (R), vert (V)
et bleu (B). On appelle ce procédé
captation en « couleurs vraies » ou
RVB.
Norme : par la Commission Internationale
de l’éclairage aux longueurs
d’ondes de 546,1 nanomètre pour
le rouge, 700,0 nanomètre pour le
vert et 435,8 nanomètre pour le
bleu.
Filtre de Bayer
Filtre de Bayer
Pavage privilégiant le vert (l’œil y est plus sensible)
Couleur pixel central :

Bleu = 200
Rouge = (237+63+255+150)/4=176
Vert = (133+80+255+160)/4=157
Codage en 24 bits : 8 bits / couleur (256 niveaux pour
chaque couleur), donc 256 · 256 · 256 = 16′ 777′ 216
Filtre de Bayer couleurs diérentes. La palette comporte plus de 16
millions de couleurs.
Palette de couleur
Autre manière de coder les images : la palette de couleur.
Choix : « palette » de 256

couleurs
Indexation de chaque pixel
à l’une de ces couleurs.
Taille et poids d’une image
Couleurs vraies : 3 octets / pixel

Image 252 x 256 pixels =64’512
pixels

pixels
⇒ 3· 64’512 = 193’536 octets

pixels
⇒ 3· 64’512 = 193’536 octets
⇒ Total : 189Kio

pixels
⇒ 3· 64’512 = 193’536 octets
⇒ Total : 189Kio
En réalité : 65,2 Kio (compression)
Couleurs indexées : avec palette et index

Image 252 x 256 pixels =64’512 pixels
pixels
⇒ 3· 64’512 = 193’536 octets
⇒ Total : 189Kio

pixels Index sur 1 octet : 1 octet/pixel
Couleurs vraies : 3 octets / pixel 64’512 octets ⇒ 63 Kio
⇒ 3· 64’512 = 193’536 octets
⇒ Total : 189Kio

⇒ 3· 64’512 = 193’536 octets Palette 256 x 3 octets = 768 octets
⇒ Total : 189Kio ⇒ 0,75 Kio

En réalité : 65,2 Kio (compression) ⇒ Total : 63,75 Kio

En réalité : 65,2 Kio (compression) ⇒ Total : 63,75 Kio
En réalité : 18 Kio (compression)
Formats d’image : chier .bmp (bitmap)
Éditeur texte Éditeur binaire
BMF..... 01000010 01001101 01000110 00000000 00000000 00000000 00000000 00000000

00000000 00000000 00110110 00000000 00000000 00000000 00101000 00000000
..6...(. 00000000 00000000 00000010 00000000 00000000 00000000 00000010 00000000
........ 00000000 00000000 00000001 00000000 00011000 00000000 00000000 00000000
........ 00000000 00000000 00010000 00000000 00000000 00000000 00010011 00001011
00000000 00000000 00010011 00001011 00000000 00000000 00000000 00000000
........ 00000000 00000000 00000000 00000000 00000000 00000000 11111111 00000000
........ 00000000 11111111 11111111 11111111 00000000 00000000 00000000 00000000
11111111 00000000 11111111 00000000 00000000 00000000
......ÿ.
.ÿÿÿ....
ÿ.ÿ...
Codage hexadécimal (chier .bmp)
Fichier hexadécimal L’image correspondante

42 4d 46 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 02 00 00 00 02 00 00 00 01 00 18 00 00 00
00 00 10 00 00 00 13 0b 00 00 13 0b 00 00 00 00
00 00 00 00 00 00 ff 00 00 ff ff ff 00 00 00 00
ff 00 ff 00 00 00
Hexadécimal
Un nombre hexadécimal est constitué de 16 chires diérents.

La correspondance avec le décimal est la suivante :
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
0 1 2 3 4 5 6 7 8 9 A B C D E F
A l’instar de la base 10, le correspondant décimal d’un nombre hexadécimal se
calcule de la manière suivante :
Décimal : 930 = 9 · 102 + 3 · 101 + 0 · 100

Hexadécimal : 3A 2 = 3 · 162 + A · 161 + 2 · 160
= 768 + 160 + 2 = 930
Exercices 1→1 . . . 9→9 / 10→A / 11→B / 12→C / 13→D / 14→E / 15→F
Convertissez les nombres hexadécimaux suivants en décimal

5F, 12, 5, A1, DD, F, 4E, 3B et 43.

5F, 12, 5, A1, DD, F, 4E, 3B et 43.
5Fhex =dec 5 · 16 + F = 80 + 15 = 95

5F, 12, 5, A1, DD, F, 4E, 3B et 43.
5Fhex =dec 5 · 16 + F = 80 + 15 = 95
12h =d 1 · 16 + 2 = 18

5F, 12, 5, A1, DD, F, 4E, 3B et 43.
5Fhex =dec 5 · 16 + F = 80 + 15 = 95
12h =d 1 · 16 + 2 = 18
5h =d 5, A 1h =d 10 · 16 + 1 = 161, DDh =d 221 Fh =d 15, 4Eh =d 78,
3Bh =d 59 et 43h =d 67
Convertissez les nombres décimaux suivants en hexadécimal

4, 9, 12, 15, 22, 24, 33, 102, 250, 4343 et 3853
4d =h 4, 9d =h 9, 12d =h C , 15d =hex F

5F, 12, 5, A1, DD, F, 4E, 3B et 43.
5Fhex =dec 5 · 16 + F = 80 + 15 = 95
12h =d 1 · 16 + 2 = 18
3Bh =d 59 et 43h =d 67

4, 9, 12, 15, 22, 24, 33, 102, 250, 4343 et 3853
4d =h 4, 9d =h 9, 12d =h C , 15d =hex F
22d =h 1 · 16 + 6 = 16, 24d =h 1 · 16 + 8 = 18, 33d =h 2 · 16 + 1 = 21

5F, 12, 5, A1, DD, F, 4E, 3B et 43.
5Fhex =dec 5 · 16 + F = 80 + 15 = 95
12h =d 1 · 16 + 2 = 18
3Bh =d 59 et 43h =d 67

4, 9, 12, 15, 22, 24, 33, 102, 250, 4343 et 3853
4d =h 4, 9d =h 9, 12d =h C , 15d =hex F
22d =h 1 · 16 + 6 = 16, 24d =h 1 · 16 + 8 = 18, 33d =h 2 · 16 + 1 = 21
102d =h 6 · 16 + 6 = 66, 250d =h 15 · 16 + 10 = FA

5F, 12, 5, A1, DD, F, 4E, 3B et 43.
5Fhex =dec 5 · 16 + F = 80 + 15 = 95
12h =d 1 · 16 + 2 = 18
3Bh =d 59 et 43h =d 67

4, 9, 12, 15, 22, 24, 33, 102, 250, 4343 et 3853
4d =h 4, 9d =h 9, 12d =h C , 15d =hex F
22d =h 1 · 16 + 6 = 16, 24d =h 1 · 16 + 8 = 18, 33d =h 2 · 16 + 1 = 21
102d =h 6 · 16 + 6 = 66, 250d =h 15 · 16 + 10 = FA
4343d =h 1 · 163 + 0 · 162 + 15 · 161 + 7 · 160 = 10F 7

5F, 12, 5, A1, DD, F, 4E, 3B et 43.
5Fhex =dec 5 · 16 + F = 80 + 15 = 95
12h =d 1 · 16 + 2 = 18
3Bh =d 59 et 43h =d 67

4, 9, 12, 15, 22, 24, 33, 102, 250, 4343 et 3853
4d =h 4, 9d =h 9, 12d =h C , 15d =hex F
22d =h 1 · 16 + 6 = 16, 24d =h 1 · 16 + 8 = 18, 33d =h 2 · 16 + 1 = 21
102d =h 6 · 16 + 6 = 66, 250d =h 15 · 16 + 10 = FA
4343d =h 1 · 163 + 0 · 162 + 15 · 161 + 7 · 160 = 10F 7
3853d =h 15 · 162 + 0 · 161 + 13 · 160 = F 0D
Et les couleurs ?
En vraie couleur (RVB), donnez le code hexadécimal du rouge, du bleu et du vert.

Et les couleurs ?
F F 0 0 0 0 , pour le rouge car on a 8 bits / couleur, soit 256 niveaux par

R V B
couleur (de 0 à 255) : deux chires hexadécimaux = 16 · 16 = 256

Et les couleurs ?
F F 0 0 0 0 , pour le rouge car on a 8 bits / couleur, soit 256 niveaux par

R V B
couleur (de 0 à 255) : deux chires hexadécimaux = 16 · 16 = 256

0000FF, pour le bleu et 00FF00 pour le vert, car le codage est RVB.
Et les couleurs ?
En vraie couleur (RVB), donnez le code hexadécimal de la couleur comprenant

30% de rouge, 20% de vert et 10% de bleu.
Et les couleurs ?

30% R : 0, 3 · 256 = 77dec =hex 4D

Et les couleurs ?

30% R : 0, 3 · 256 = 77dec =hex 4D

20% V : 51dec =hex 33
Et les couleurs ?

30% R : 0, 3 · 256 = 77dec =hex 4D

20% V : 51dec =hex 33
10% B : 26dec =hex 1A
Et les couleurs ?

30% R : 0, 3 · 256 = 77dec =hex 4D

20% V : 51dec =hex 33
10% B : 26dec =hex 1A
Donc 4D331A
Et les couleurs ?

30% R : 0, 3 · 256 = 77dec =hex 4D

20% V : 51dec =hex 33
10% B : 26dec =hex 1A
Donc 4D331A
Et les couleurs ?
En vraie couleur, donnez le code hexadécimal de la couleur comprenant 50% de

rouge, 80% de vert et 3% de bleu.
50% R : 0, 5 · 256 = 128dec =hex 80

Et les couleurs ?

50% R : 0, 5 · 256 = 128dec =hex 80

80% V : 205dec =hex CD
Et les couleurs ?

50% R : 0, 5 · 256 = 128dec =hex 80

3% B : 8dec =hex 08
Et les couleurs ?

50% R : 0, 5 · 256 = 128dec =hex 80

3% B : 8dec =hex 08
Donc 80CD08
Et les couleurs ?

50% R : 0, 5 · 256 = 128dec =hex 80

3% B : 8dec =hex 08
Donc 80CD08
En vériant avec Gimp
Les deux couleurs dénies dans les exercices précédents sont :

Exemple du chier BMP
Structure du cher .bmp

Nous allons ici choisir un format un peu désuet, mais qui ore les avantages
suivants :
structure relativement simple
pas de compression qui compliquerait énormément la lecture...
Exemple du chier BMP
Structure du cher .bmp

Voici la structure standard du chier BMP
42 4D Caractère B et M pour désigner un bitmap
46 00 00 00 Taille du chier 46 = 70 octets
00 00 00 00 Réservé toujours à 0
chier
36 00 00 00 Position (oset) de l’image 36 = 54 octets
28 00 00 00 Taille de l’entête du chier 28 = 40 octets
02 00 00 00 Largeur de l’image : 2 pixels
02 00 00 00 Hauteur de l’image : 2 pixels
01 00 nombre de plans utilisés
18 00 nombre de bits par pixel 18 = 24 bits/pixel (3 octets)
00 00 00 00 Méthode de compression (0 pas de compression)
10 00 00 00 Taille de l’image 10 = 16 octets
13 0b 00 00 Résolution horizontale 0b13 = 2835 pixel par mètre
Entêtes image
13 0b 00 00 Résolution verticale 0b13 = 2835 pixel par mètre
00 00 00 00 Nombre de couleurs de la palette : 0 palette complète
00 00 00 00 Nombre de couleurs importantes de la palette
 00 00 B=255,V=0,R=0 : bleu
 B=255, V=255, R=255 : blanc
00 00 Pour que la ligne ait un nb d’octets multiple de 4
00 00  B=0, V=0, R=255 : rouge
Image
00  00 B=0, V=255, R=0 : vert
00 00 Pour que la ligne ait un nb d’octets multiple de 4
Exercice : ceci est une image . . .
Type d’image ?
42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00 Nb d’octets ?
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00
00 00 00 00 00 00 ff ff ff ff ff ff ff ff ff 00 Oset ?
00 ff ff ff ff ff ff ff ff ff ff 00 00 00 ff ff
ff ff ff ff 00 00 ff 00 00 ff 00 00 ff ff ff ff
Largeur ?
ff ff ff 00 00 00 ff ff ff 00 00 ff ff 00 00 ff Hauteur ?
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
ff ff ff ff ff 00 00 ff 00 00 ff ff ff ff ff ff Nb octets/pixel ?
00 00 ff 00 00 00 00 00 ff ff ff ff ff 00 00 00
00 ff ff 00 00 ff ff ff 00 00 ff 00 00 00 ff ff Taille image ?
ff 00 00 ff 00 00 ff ff ff ff 00 00 ff ff 00 00
ff ff ff 00 00 00 ff ff ff ff ff ff ff ff ff ff
Que représente-elle ?
ff ff ff ff ff ff ff ff ff 00 00 00 00 00 Taille (en ko) ?
BM car 42H = 66D = BASCII et

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 Nb d’octets ?
00 00 00 00 00 00 ff ff ff ff ff ff ff ff ff 00
00 ff ff ff ff ff ff ff ff ff ff 00 00 00 ff ff Oset ?
ff ff ff 00 00 00 ff ff ff 00 00 ff ff 00 00 ff Largeur ?
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
ff ff ff ff ff 00 00 ff 00 00 ff ff ff ff ff ff Hauteur ?
00 00 ff 00 00 00 00 00 ff ff ff ff ff 00 00 00 Nb octets/pixel ?
00 ff ff 00 00 ff ff ff 00 00 ff 00 00 00 ff ff
ff 00 00 ff 00 00 ff ff ff ff 00 00 ff ff 00 00 Taille image ?
ff ff ff ff ff ff ff ff ff 00 00 00 00 00 Que représente-elle ?
Taille (Kio) ?

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 deH = 222D octets
00 ff ff ff ff ff ff ff ff ff ff 00 00 00 ff ff Oset ?
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
Taille (Kio) ?

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 deH = 222D octets
00 ff ff ff ff ff ff ff ff ff ff 00 00 00 ff ff 36H = 54D octets
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
Taille (Kio) ?

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 deH = 222D octets
ff ff ff 00 00 00 ff ff ff 00 00 ff ff 00 00 ff 07H = 7 pixels
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
Taille (Kio) ?

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 deH = 222D octets
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
ff ff ff ff ff 00 00 ff 00 00 ff ff ff ff ff ff 07H = 7 pixels
Taille (Kio) ?

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 deH = 222D octets
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
00 00 ff 00 00 00 00 00 ff ff ff ff ff 00 00 00 18H = 24D bits/pixel,soit 3 octets/pixel
Taille (Kio) ?

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 deH = 222D octets
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
ff 00 00 ff 00 00 ff ff ff ff 00 00 ff ff 00 00 a8H = 168D octets
Taille (Kio) ?

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 deH = 222D octets
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
ff ff ff ff ff ff ff ff ff 00 00 00 00 00 Un cœur percé.
Taille (Kio) ?

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 deH = 222D octets
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
00 00 ff 00 00 00 00 00 ff ff ff ff ff 00 00 00
18H = 24D bits/pixel,soit 3 octets/pixel
222 octets, soit 0,217 Kio

42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
4dH = 77D = MASCII
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00 deH = 222D octets
00 00 ff 00 00 00 00 ff ff ff ff 00 00 00 00 00
00 00 ff 00 00 00 00 00 ff ff ff ff ff 00 00 00
18H = 24D bits/pixel,soit 3 octets/pixel
222 octets, soit 0,217 Kio
Une autre interprétation de cette image

C’est plus naturel...
Une autre image . . . corrompue.
42 4d e1 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 17 00 00 00
00 00 aa 00 00 00 13 0b 00 00 13 0b 00 00 00 00 Ce chier en 2 couleurs
00 00 00 00 00 00 00 ff 00 00 87 00 ff ff ff ff
ff ff ff ff ff ff ff ff ff ff ff 00 00 10 00 ff vraies a été corrompu.
00 00 87 00 ff ff ff ff ff ff ff ff ff ff ff ff
ff ff ff 00 00 00 00 ff 00 00 83 00 00 87 00 ff Que représente-t-il ?
ff ff ff ff ff ff ff ff ff ff ff 00 00 00 00 ff Pouvez-vous le corriger ?
00 00 ff 00 00 ff 00 00 ff 00 ff ff ff ff ff ff
ff ff ff 00 00 00 00 ff 00 00 86 00 ff ff ff ff Quel est le poids de cette
ff ff ff ff ff ff ff ff ff ff ff 00 00 00 00 ff image en Mio ?
00 00 87 00 00 87 00 00 87 00 00 87 00 00 87 00
ff ff ff 00 00 00 00 ff 00 00 ff 00 00 ff 00 00
ff 00 00 ff 00 00 ff 00 00 ff 00 00 00 00
Le chier une fois corrigé.
42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00 Nombre total d’octet (deux chires hexadécimaux) :
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00
00 00 00 00 00 00 00 ff 00 00 87 00 ff ff ff ff
ff ff ff ff ff ff ff ff ff ff ff 00 00 00 00 ff 14 · 16 − 2 = 222D = de H
ff ff ff 00 00 00 00 ff 00 00 87 00 00 87 00 ff
ff ff ff ff ff ff ff ff ff ff ff 00 00 00 00 ff Nombre de bits par pixel en vraie couleurs :
ff ff ff 00 00 00 00 ff 00 00 87 00 ff ff ff ff
ff ff ff ff ff ff ff ff ff ff ff 00 00 00 00 ff 24D = 18H
00 00 87 00 00 87 00 00 87 00 00 87 00 00 87 00
ff ff ff 00 00 00 00 ff 00 00 ff 00 00 ff 00 00
ff 00 00 ff 00 00 ff 00 00 ff 00 00 00 00 Taille image 7 pixel sur 7 pixel (3 octets par pixel avec
un nombre d’octets multiple de 4 par ligne ⇒ 3 octets
suppl. par ligne) :
7 · 7 + 3 · 7 = 168D = a8H
00 dans les octets supplémentaires par ligne.

87 pour la couleur verte sombre (bichromie).
Le modèle RVB
R : 8 bits, 1 octet → 256 niveaux de

rouge
(0 pas de rouge, 255 rouge pur)
V : 8 bits, 1 octet → 256 niveaux de

vert
(0 pas de vert, 255 vert pur)
B : 8 bits, 1 octet → 256 niveaux de

bleu
(0 pas de bleu, 255 bleu pur)
Le modèle Teinte-Saturation-Valeur
Un autre modèle utilisé pour décrire une couleur :

le modèle Teinte-Saturation-Valeur
Teinte : correspond à la couleur sur 360◦ selon un
angle trigonométrique.
Le rouge se situe à 0◦ et 360◦
le jaune à 60◦
le vert à 120◦
le cyan à 180◦
le bleu à 240◦
le magenta à 300◦ .
Saturation : correspond à la quantité de couleur « dans
le blanc ».
Valeur : correspond, quant à elle, à la quantité de
couleur « dans le noir ».
Le modèle Teinte-Saturation-Valeur : exemples
Bleu peu saturé Bleu peu valorisé

Le modèle Teinte-Saturation-Valeur
Principe mathématique
Si on considère M et m, respectivement, comme le maximum et le minimum des
valeurs de l’ensemble (R,V,B), les valeurs T (teinte), S (saturation) et V (valeur)
sont données par l’ensemble des relations ci-dessous où T ∈ [0, 360].
0 si M=m
V−B
60 · + 0◦ si M=R et V ⩾ B

M−m


V−B

+ 360◦ si M = R et V < B

60 · M−m



B −R


+ 120◦ si M = V

60 · M−m
T= 
R−V

+ 240◦ si M=B

60 · M−m






0 si M = 0
S=
(1 − m

M ) · 100 sinon
M
V= · 100
255
Exercices
Les couleurs suivantes sont données selon le modèle RVB. Trouvez les valeurs
selon le modèle TSV, puis à l’aide de gimp, décrivez la couleur
(34,56,239)
Exercices
(34,56,239) ⇒ (234,86,94) bleu très saturé et valorisé llllllllllllllllll
Exercices
(22,240,200)
Exercices
(22,240,200) ⇒ (169,91,94) bleu-vert très saturé et valorisé llllllllllllllllll
Exercices
(255,231,176)
Exercices
(255,231,176) ⇒ (42,31,100) orange peu saturé et très valorisé llllllllllllllllll
Exercices
(13,53,30)
Exercices
(13,53,30) ⇒ (146,76,21) vert très saturé et très peu valorisé llllllllllllllllll
Exercices
(13,53,30) ⇒ (146,76,21) vert très saturé et très peu valorisé llllllllllllllllll
Compression RLE : non destructive
Codage par plage ou Run-Length Encoding.

Idée : chaque octet (deux nombres hexadécimaux) est codé par le nombre de ses
occurrences successives et sa valeur.
Exemple : la chaine . . .
00 00 00 0A 12 00 00 23 23 23 23 12 12 AB AB AB AB AB
...est alors codée de la manière suivante :

Compression RLE : avantages & inconvénients
Avantages : plus il existe de plages identiques, plus la compression est

importante.
Inconvénients : pour des images très détaillées, ce codage peut augmenter
la taille de l’image :
Un eet regrettable...
01 00 AE AB 1C 3F → 01 01 01 00 01 AE 01 AB 01 1C 01 3F
Conclusion : Cette méthode est bien adaptée à de grands aplats de
couleurs identiques et aux images monochrome ou en un nombre restreint
de couleurs (256 par exemple).
Utilisée pour les icônes ou les documents au trait.
Compression de Humann : non destructive
Idée : coder les lettres fréquentes par des bits de poids faibles.
Une chaine comprenant cinq lettres
ssionnansnni ← oaisn
Pour coder cinq lettres, il faut au minimum trois bits : 23 = 8.
Un codage peu intelligent
o → 000 ; a → 001 ; i → 010 ; s → 011 ; n → 100
o → 000 ; a → 001 ; i → 010 ; s → 011 ; n → 100
Le résultat est une chaîne de 12 · 3 = 36 bits pour douze caractères.
o → 000 ; a → 001 ; i → 010 ; s → 011 ; n → 100
Le résultat est une chaîne de 12 · 3 = 36 bits pour douze caractères.
La chaine encodée
011|011|010|000|100|100|001|100|011|100|100|010
Méthode : éléments de plus basse fréquence 2 à 2.
Meilleure idée : on regarde la fréquence d’apparition des lettres pour créer

l’arbre suivant.
Méthode : éléments de plus basse fréquence 2 à 2.
Meilleure idée : on regarde la fréquence d’apparition des lettres pour créer

l’arbre suivant.
Arbre de Human : construction
12×
< c
5×
n ; 7× b
3×
s < 4× b
2×
i < 2×a
1× 1×
a o
Méthode : 1 sur bit fort pour éléments basse fréquence.
Arbre de Human : codage
12×
0 1
y &
(0) n 7×
0 1
y '
(10) s 4×
0 1
w %
(110) i 2×
0 1
y %
(1110) a o (1111)
Codage de Humann
Selon l’arbre de Humann, la lettre n est codée 0, la lettre s est codée 10, la lettre
i est codée 110, la lettre a est codée 1110 et la lettre o codée 1111
Codage de Humann
ssionnansnni → 10|10|110|1111|0|0|1110|0|10|0|0|110
soit 25 bits au lieu de 36 ! Une compression de 30% !
De plus, le codage permet la suppression des bits nuls de poids fort.
Le codage est UNIVOQUE (il ne peut pas y avoir d’ambiguité).
Méthode : on lit simplement en suivant l’arbre.
Arbre de Human : décodage 1010110. . .
12×
0 1
y &
(0) n 7×
0 1
y '
(10) s 4×
0 1
w %
(110) i 2×
0 1
y %
(1110) a o (1111)
Exercice sur la compression
Exercice
Déterminez le poids de l’image du double F précédemment présentée, mais codée
selon RLE puis selon Humann.
Compression RLE pour le double F
42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
01 42 01 4d 01 de 07 00 01 36 03 00 01 28 03 00
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00
01 07 03 00 01 07 03 00 01 01 01 00 01 18 05 00
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00
01 a8 03 00 01 13 01 0b 02 00 01 13 01 0b 0B 00
00 00 00 00 00 00 00 ff 00 00 87 00 ff ff ff ff
01 FF 02 00 01 87 01 00 0F FF 04 00 01 FF 02 00
ff ff ff ff ff ff ff ff ff ff ff 00 00 00 00 ff
01 87 01 00 0F FF 04 00 01 FF 02 00 01 87 02 00
01 87 01 00 0C FF 04 00 01 FF 02 00 01 FF 02 00
ff ff ff 00 00 00 00 ff 00 00 87 00 00 87 00 ff
01 FF 02 00 01 FF 01 00 09 FF 04 00 01 FF 02 00
01 87 01 00 0F FF 04 00 01 FF 02 00 01 87 02 00
01 87 02 00 01 87 02 00 01 87 02 00 01 87 01 00
03 FF 04 00 01 FF 02 00 01 FF 02 00 01 FF 02 00
01 FF 02 00 01 FF 02 00 01 FF 02 00 01 FF 04 00
00 00 87 00 00 87 00 00 87 00 00 87 00 00 87 00
ff ff ff 00 00 00 00 ff 00 00 ff 00 00 ff 00 00
ff 00 00 ff 00 00 ff 00 00 ff 00 00 00 00
16 x 14 - 2 = 222 octets 16 x 11 = 176 octets

Compression RLE :
222 − 176
c= · 100 = 20, 7 %
222
Compression de Humann pour le double F
42 4d de 00 00 00 00 00 00 00 36 00 00 00 28 00
Octets Fréquence
00 00 07 00 00 00 07 00 00 00 01 00 18 00 00 00 42, 4d, de, 36,
00 00 a8 00 00 00 13 0b 00 00 13 0b 00 00 00 00
00 00 00 00 00 00 00 ff 00 00 87 00 ff ff ff ff 28, 01, 18, a8 1
ff ff ff 00 00 00 00 ff 00 00 87 00 00 87 00 ff 07, 13, 0b 2
00 00 ff 00 00 ff 00 00 ff 00 ff ff ff ff ff ff 87 10
ff ff ff ff ff ff ff ff ff ff ff 00 00 00 00 ff  85
00 00 87 00 00 87 00 00 87 00 00 87 00 00 87 00
ff ff ff 00 00 00 00 ff 00 00 ff 00 00 ff 00 00
ff 00 00 ff 00 00 ff 00 00 ff 00 00 00 00 00 113
16 x 14 - 2 = 222 octets
14 symboles : 24 = 16 ⇒ 4 bits
Arbre de Humann
0
00 o 222×
1
0
%
o 109×
1
0
$
87 o 24×
1
0 *
0
6× o 14×
1
~ # 1
0
4× 0b 0
8×
1 1
~
13 07 0
4× r 0
+ 4×
1 1
t ) w (
0
2× 0
2× 0
2× 0
2×
1 1 1 1
~ # | ~ ~
a8 18 01 28 36 de 4d 42
Codage de Humann
Arbre binaire => 14 symboles sur 7 bits !

Octets Fréquence codage Total
42, 4d, de, 36,
28, 01, 18, a8 1 7 bits ⇒ 8 · 7 = 56 bits
07, 13, 0b 2 6 bits ⇒ 3 · 2 · 6 = 36 bits
87 10 3 bits ⇒ 10 · 3 = 30 bits
 85 2 bits ⇒ 85 · 2 = 170 bits
00 113 1 bits ⇒ 113 · 1 = 113 bits
total : 405 bits = 51 octets
Codage de Humann
Arbre binaire => 14 symboles sur 7 bits !

Octets Fréquence codage Total
42, 4d, de, 36,
28, 01, 18, a8 1 7 bits ⇒ 8 · 7 = 56 bits
07, 13, 0b 2 6 bits ⇒ 3 · 2 · 6 = 36 bits
87 10 3 bits ⇒ 10 · 3 = 30 bits
 85 2 bits ⇒ 85 · 2 = 170 bits
00 113 1 bits ⇒ 113 · 1 = 113 bits
total : 405 bits = 51 octets
Compression Humann :
222 − 51
Compression : c = · 100 = 77%
222
Principaux formats d’image
TIFF (Tag Image File Format)
Pour les professionnels de l’image.

Non compressé : images sans perte de qualité.
Compressé (LZW (Lempel-Ziv-Welch) pour images ayant peu de couleurs ou
d’autres . . .) sans perte de dénition (non destructif).
Taille importante : pas recommandé pour une utilisation sur le web.
Format propriétaire (Adlus, Adobe). Avec le JPG et malgré qu’il soit
propriétaire, c’est le format de numérisation du ministère de la culture en
France.
JPEG ou JPG (Joint Photographic Expert Group)
Pour le web.
Compressé en fonction de la qualité de l’image nale désirée (RLE, Humann
et transformée de fourrier).
Pas un format propriétaire mais plutôt une norme publique, même si certains
en revendiquent la paternité.
Utilisé communément par les appareils photographique numérique.
C’est LE format le plus utilisé aujourd’hui.
GIF (Graphics Interchange Format)
Format 8 bits, c’est-à-dire avec au maximum 256 couleurs.

Images sont donc de petite taille adaptées au web.
Images de type logo ou dessin animés. Banderoles et autres petits dessins
animés égayant les pages web.
Ce format totalement propriétaire (Compuserve) est maintenant dans le
domaine publique depuis peu.
PNG (Portable Network Graphics)
Destiné à remplacer progressivement le format GIF sur internet.

Meilleur taux de compression (compression png) que le GIF.
Format totalement libre.
EPS (Encapsuled Post Script)
Langage compris directement par une imprimante postscript.

Gère des images de type bitmap (ensemble de points) ou vectorielle (des
courbes et lignes).
Comprend le RVB ou le CMJN.
Pas un format propriétaire.
Format d’image. Ne pas confondre avec le PostScript qui n’est pas à
proprement parlé un format d’image, mais un langage d’instruction
d’impression.
PDF (Portable Document Format)
Pour la visualisation et l’impression d’un document indépendamment de la

plate-forme.
Peu gourmand en espace et est donc intéressant pour le web.
Non compressé ou compressé non destructif.
Format propriétaire (Adobe), mais ouvert et parfaitement documenté.
Constituants des pages
Un site web est constitué de :


Structure et contenu HTML ou XHTML

Présentation avec les feuilles de style CSS

Graphisme et intégration des images GIF, JPG, PNG, MNG.

Anciennement, animation en Flash, aujourd’hui avec attributs CSS3 ou SVG
et javascript.

et javascript.
Incorporation de multimédias (sons, vidéos...).

et javascript.
Dynamisme au niveau de la gestion de contenu (coté serveur) avec des
langages de développement de type PHP, Java ... fonctionnant avec un
serveur Web.

et javascript.
Dynamisme au niveau de la gestion de contenu (coté serveur) avec des
langages de développement de type PHP, Java ... fonctionnant avec un
serveur Web.
Des bases de données de type SQL ou XML.
Côté client
La notion de client-serveur désigne un mode de communication dans un réseau,

comme par exemple un réseau internet.
Côté client
La notion de client-serveur désigne un mode de communication dans un réseau,

comme par exemple un réseau internet.
Le client
Le client envoie des requêtes. Exemple, l’utilisateur internaute clique sur un lien. Il
envoie donc une requête au serveur sur lequel le site est installé. Il passe par un
navigateur qui envoie la requête, puis interprète les pages HTML que lui retourne
le serveur pour les afcher.
Côté serveur
Le serveur
Le serveur attend les requêtes de

l’utilisateur (serveur web), réunit ce
qu’il est nécessaire pour composer
une réponse (base de donnée), la
construit (php) et la retourne au
client.
Versions
Il existe plusieurs versions de HTML qui ne sont pas compatibles avec tous les
navigateurs.
En 2014, la norme HTML5 devrait a été ofcialisée. C’est donc sur celle-ci qu’on
va se baser. Elle est compatible avec tous les navigateurs récents dans la plupart
des cas.
Structure de balisage
Attention, HTML 5 est moins strict que XHTML !

Bonne pratique : fermer les balises.
Ouverture - fermeture
<nom_balise> texte </nom_balise>
Hiérarchie
<balise1><balise2> texte </balise2></balise1>
Balisage
Structure : <html>, <head>, <body>

Head : <title>, <meta>, <style>, <link>, <script>
Body : <div>, <header>, <article>, <nav>, <aside>, <footer>, <h1>, <h2-5>, <p>, <a>
(lien internet), <table>, <tr> (ligne), <td> (colonne), <hr /> (ligne), <img />, <audio />,
<video />, <br /> (saut ligne), <b>, <strong>, <i>, <em>, <span>, <button>, . . .
Attributs
Les balises peuvent avoir des attributs ou propriétés :

<balise attribut1=“valeur1” attribut2=“valeur2”> . . . </balise>
Exemples :
Liens internet :
<a href=“http ://www.wikipedia.org”> Wikipedia</a>
Ligne horizontale :
<hr width=’150px’ align=’left’/>
Image :
<img src=“/repertoire/image.jpg”/>
Image - lien :
<a href=“http ://www.google.ch”>Google</a>
Structure générale
La structure générale d’une page HTML est la suivante :

< ! DOCTYPE html> –> la déclaration du type HTML5 du document
<html> –> balise d’ouverture du document
<head> –> balise d’ouverture de l’entête
... ...
</head> –> balise de fermeture de l’entête
<body> –> balise d’ouverture du corps du document
... ...
</body> –> balise de fermeture du corps du document
</ html> –> balise de fermeture du document
La structure générale de l’entête est la suivante :

<head> –> balise d’ouverture de l’entête
<meta charset= " UTF−8 " /> –> Codage des caractères utilisés
<meta name= " d e s c r i p t i o n " –> balise de description de la page
content=" D e s c r i p t i o n ␣page " /> ...
<meta name= " author " –> balise de déclaration de l’auteur
content="mon␣nom" /> ...
< t i t l e > T i t r e de l a f e n e t r e</ t i t l e > –> balise de titre de la fenêtre
<l i n k r e l=" stylesheet " –> balise de feuille de style externe
href= " s t y l e . css " /> ...
<s t y l e> . . . </ s t y l e> –> balise de feuille de style interne
< s c r i p t> . . . </ s c r i p t> –> balise de script
</head> –> balise de fermeture de l’entête
La structure générale du corps est la suivante :

<body> –> balise d’ouverture du corps
<header> . . . </ header> –> balise de l’entête (logo, titre, . . .)
<nav> . . . </ nav> –> balise de la barre de navigation
<a s i d e> . . . </ a s i d e> –> balise de colonne latérale droite
< a r t i c l e > . . . </ a r t i c l e > –> balises des articles
... –> . . .
< f o o t e r> . . . </ f o o t e r> –> balise du pied de page (copyright, . . .)
</body> –> balise de fermeture du corps
Voici l’illustration de cette structure :

Intégration des feuilles de styles
Trois cas sont envisageables :

Dans la balise.
<p s t y l e = " c o l o r : red ; font − s i z e :100 ">Texte</p>
Feuille interne
Feuille externe
<head>
<s t y l e type= " t e x t / css "> <head>
p {
< l i n k r e l = " s t y l e s h e e t " type=" t e x t
c o l o r : red ;
} / css " href= " f e u i l l e . css " />
</ s t y l e> </head>
</head>
Feuilles de styles : CSS
Idée : séparer le contenu de la forme. Syntaxe :
sélecteur {propriété :valeur}
Meilleure indentation :
Exemples : h1, h2 {
h1 {font-size :120 ;}
font-family : "sans serif" ;
p {font-family :"sans serif" ; color : red ;
font-size :90% ; color :red}
}
Feuilles de styles : sélecteurs
Sélecteurs imbriqués : Sélecteur identié :

Toutes les sélections (span) de chaque Attention le sélecteur identié est unique !
paragraphes (p) sont passées en rouge. En d’autres termes, on ne peut mettre
plusieurs identiants identiques.
<p>La voiture est <span>très</span>
petite</p> <p id=“cetexte”>Un pti texte</p>
p span {color : red ;} #cetexte {color : red}
La voiture est très petite Un ptit texte
Sélecteurs de classe : Il s’agit d’appliquer

un style à un ensemble d’éléments donnés.
Sélecteur contextuel : Il s’agit d’appliquer
un style suivant le contexte.
<h1 class=“laclass”>La </h1>
<em class=“laclass”>deux chevaux, </em>
<div>Le vélo, c’est bien</div>
<p class=“laclass”>sa puissance </p>
<p>c’est la lenteur.</p> div :hover {background-color : red ;}
.laclass {color :red} Ici, en passant la souris sur le div, il devient
rouge.
La deux chevaux, sa puissance c’est la
lenteur.
Plusieurs sélecteurs : Il s’agit d’appliquer le

même style à plusieurs sélecteurs diérents.
<h1>La </h1>
<em>deux chevaux, </em>
<p>sa puissance </p> Et d’autre encore . . . A découvrir.
<p>c’est la lenteur.</p>
h1, em, p {color :red}
La deux chevaux, sa puissance c’est la

lenteur.
Animation javascript 1 : image, gif animé
Première idée :
Déplacement du gif animé en javascript
<img src = ’ tux . png ’ / >
f u n c t i o n deplace ( ) {
i d e n t i f i c a t i o n = document . getElementById ( ’ robot ’ )
position = parseInt ( i d e n t i f i c a t i o n . style . l e f t )
... avec un gif animé ... p o s i t i o n = p o s i t i o n + 10
i d e n t i f i c a t i o n . s t y l e . l e f t = p o s i t i o n + " px "
}
<img src = ’ robot . g i f ’ / >
Résultat
Code
Animation javascript 2 : tableau d’images
On crée un tablau de références

d’images : On appelle à intervalle régulier la
fonction :
Tableau
Animation
var i m g F i l e s = new Array (
" Cours / Cours_e0000 . g i f " , f u n c t i o n animate ( ) {
" Cours / Cours_e0001 . g i f " , frame += 1
" Cours / Cours_e0002 . g i f " , i f ( frame > i m g F i l e s . l e n g t h ) {
" Cours / Cours_e0003 . g i f " , frame = 0
" Cours / Cours_e0004 . g i f " , }
" Cours / Cours_e0005 . g i f " , s p r i t e I m a g e . s r c = i m g F i l e s [ frame ]
" Cours / Cours_e0006 . g i f " , }
" Cours / Cours_e0007 . g i f "
)
Résultat
Code
Animation javascript 3 : une seule image
Frames juxtaposées en css

# contenant { Parcours de l’image
background −image : u r l ( " Cours / Cours_8 . g i f " ) ;
h e i g h t : 128px ;
width : 128px ; f u n c t i o n cours ( ) {
background − p o s i t i o n : 0px 0px ; } frame++
i f ( frame >= o f f s e t L i s t . l e n g t h ) {
frame = 0
}
o f f s e t = o f f s e t L i s t [ frame ] + " px ␣0px "
Tableau des décalages contenant . s t y l e . b a c k gr o un d P o s it io n = o f f s e t
}
var o f f s e t L i s t = new Array ( 0 , −128, −256, −384, −512,
−640 , −768 , −896)
Résultat
Code
Animation javascript 4 : le déplacement
Gestion du clavier
document . onkeypress = k e y L i s t e n e r
Déplacement de l’image
f u n c t i o n moveContenant ( dx , dy ) {
x = p a r s e I n t ( contenant . s t y l e . l e f t )
Détection des touches y = p a r s e I n t ( contenant . s t y l e . top )
x += dx
function keyListener ( e ) { y += dy
i f ( e . keyCode == 37) { contenant . s t y l e . l e f t = x + " px "
moveContenant ( −10 , 0 ) contenant . s t y l e . top = y + " px "
} // gauche }
i f ( e . keyCode == 38) {
moveContenant ( 0 , −10)
} // haut . . . }
Résultat
Code
Animation javascript 5 : le tout
Un joli résultat Un joli “petit” programme

Résultat Code

PDF - Js Viewer

Transféré par

Droits d'auteur :

Formats disponibles

PDF - Js Viewer

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

PDF - Js Viewer

Transféré par

Droits d'auteur :

Formats disponibles

Option complémentaire d’informatique

Lycée Blaise Cendrars

1 Genève : Logiciels libres.

1 Genève : Logiciels libres.

1 Genève : Logiciels libres.

1 Genève : Logiciels libres.

1 Genève : Logiciels libres.

1 Genève : Logiciels libres.

1 Genève : Logiciels libres.

1 Genève : Logiciels libres.

1 Genève : Logiciels libres.

1 Genève : Logiciels libres.

Windows MacOS© Linux

Licences propriétaires Licences libres

Licences propriétaires Licences libres

1 La liberté 3 encourage la création d’une communauté de développeurs améliorant

1 La liberté 3 encourage la création d’une communauté de développeurs améliorant

1 La liberté 3 encourage la création d’une communauté de développeurs améliorant

1 La liberté 3 encourage la création d’une communauté de développeurs améliorant

1 La liberté 3 encourage la création d’une communauté de développeurs améliorant

1 La liberté 3 encourage la création d’une communauté de développeurs améliorant

Que veut dire « GNU-Linux » ?

L’ensemble des logiciels d’un ordinateur se décompose dans deux espaces :

Noyau des système Noyau du système Linux2 .

Code Perl, Python, C, . . . Astro Celestia, Kstar,

Pour coder les caractères spéciaux, on rencontre principalement 2 normes :

Elle sépare la représentation du caractère du codage lui-même par

À un caractère correspond un seul point de code, mais peut correspondre

Fontes vectorielles – Fontes bitmap Postscript, truetype – bdf

Courbe de bézier Représentation bitmap Anti-aliasing et hinting

Le rendu des fontes se fait automatiquement au moment de

AaBbCcFcTe AaBbCcFcTe AaBbCcFcTe

Objectifs : mettre en forme du texte. Les moyens dépendent du contexte :

Traitement de texte classique. Bien que . . .

Gestion avancée des styles, références, bibliographie, index, . . .

Traitement de texte haute qualité : gestion professionnelle automatique de la

« Loxodromie et projection de Mercator » .

Autre exemple connu : votre « formulaire et tables CRM »...

Orientation web – séparation du contenu et de la forme.

Langages balisés sans boucles, fortement normalisés et strict.

Idée : structurer du contenu à l’aide de balises : < et >

Attention, 10 en binaire ne se lit pas « dix » et ne correspond pas à la valeur

Bit, byte et octet

Donc, on sait maintenant que l’octet permet de représenter 28 = 256 nombres, de

sur 32 bits, peut représenter 232 = 4294967296 (c’est beaucoup...)

sur 32 bits, peut représenter 232 = 4294967296 (c’est beaucoup...)

On a 4294967296 nombres possibles

On a 4294967296 nombres possibles

On a 4294967296 nombres possibles

On divise par 8, donc on a 1, 71 · 1010 octets

On a 4294967296 nombres possibles

On divise par 8, donc on a 1, 71 · 1010 octets

On divise par 1024, donc on a 16777216 Kio

On a 4294967296 nombres possibles

On divise par 8, donc on a 1, 71 · 1010 octets

On divise par 1024, donc on a 16777216 Kio

On divise par 1024, donc on a 16384 Mio

On a 4294967296 nombres possibles

On divise par 8, donc on a 1, 71 · 1010 octets