Quelle Calculatrice Choisir 2021 édition Universelle
Épisode 8 - Écrans et profondeurs
Épisode 8 - Écrans et profondeurs
Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :
- toutes les calculatrices graphiques Texas Instruments (depuis la première TI-81 de 1990)
- toutes les calculatrices graphiques Casio à technologie Flash (depuis 2003)
L'écran est décidément un élément incontournable de ta calculatrice graphique. Après avoir couvert dans des épisodes précédents ses dimensions, définition et zone graphique, nous allons aujourd'hui traiter de sa profondeur, c'est-à-dire du nombre de couleurs différentes qu'il permet d'afficher.
Commençons par enfoncer les portes ouvertes, avec les modèles dont le contrôleur écran ne gère que 1 bit de profondeur, ne permettant donc que 21= 2 couleurs différentes.
D'une part, voici les modèles à cristaux liquides bleus souffrant en conséquence d'une lisibilité assez pénible sans un excellent éclairage extérieur :
D'une part, voici les modèles à cristaux liquides bleus souffrant en conséquence d'une lisibilité assez pénible sans un excellent éclairage extérieur :
- Esquisse GCEXFR
- Lexibook GC3000FR
- Casio Graph 25+E
Et voici les modèles à cristaux liquides noirs, de bien meilleure lisibilité :
- Casio Graph 25+E II
- Casio Graph 35+E
- Casio Graph 35+E II
- Casio Graph 75+E
- TI-82 Advanced
- TI-84 Plus T
- Casio fx-92+ Spéciale Collège
Passons maintenant aux choses intéressantes ; nous allons te présenter notre protocole de test.
Notre idée est donc d'afficher une mire avec des dégradés des composantes primaires rouge-vert-bleu, afin de déterminer le nombre de bits utilisés par chacune.
Il y a 2 façons de coder les couleurs dans le contexte des pixels en Python :
Prévoyons une fonction pour tester le codage utilisé, par simple vérification du type de retour d'une lecture de pixel.
Dans le cas d'un retour de type entier, tentons de plus en passant de détecter le nombre de bits gérés par le contrôleur écran, en écrivant des valeurs de pixels de plus en plus grandes et vérifiant à chaque fois si le pixel concerné a bien pris la valeur en question.
Un appel
Pour notre script universel il faudra bien choisir un codage plutôt qu'un autre, alors prévoyons une fonction de conversion :
Voici de quoi tracer des lignes verticales et horizontales :
Et voici enfin notre code de tracé de la mire :
Tu vas vite comprendre tout ça avec notre premier exemple.
Notre idée est donc d'afficher une mire avec des dégradés des composantes primaires rouge-vert-bleu, afin de déterminer le nombre de bits utilisés par chacune.
Il y a 2 façons de coder les couleurs dans le contexte des pixels en Python :
- soit avec un tuple (r,g,b) décrivant les valeurs de chaque composante primaire rouge-vert-bleu par un entier de 0 à 255
- soit par un nombre entier qui sera directement la valeur fournie au contrôleur écran
Prévoyons une fonction pour tester le codage utilisé, par simple vérification du type de retour d'une lecture de pixel.
Dans le cas d'un retour de type entier, tentons de plus en passant de détecter le nombre de bits gérés par le contrôleur écran, en écrivant des valeurs de pixels de plus en plus grandes et vérifiant à chaque fois si le pixel concerné a bien pris la valeur en question.
- Code: Tout sélectionner
#0: (R,G,B) >0: RGB-bits
def get_color_mode():
c = get_pixel(0, 0)
try:
c[2]
return 0
except:
b, v = 0, 1
x, y = 0, sy0
set_pixel(x, y, v)
while get_pixel(x, y) == v:
b += 1
v *= 2
set_pixel(x, y, v)
return b
Un appel
color_mode = get_color_mode() pourra donc renvoyer par exemple :- 0 : pour un codage des couleurs par des tuples (r,g,b)
- 15 : pour un codage des couleurs sur des entiers de 15 bits
- 16 : pour un codage des couleurs sur des entiers de 16 bits
- 24 : pour un codage des couleurs sur des entiers de 24 bits
- ...
Pour notre script universel il faudra bien choisir un codage plutôt qu'un autre, alors prévoyons une fonction de conversion :
- Code: Tout sélectionner
def fixcolor(c, bits=16):
try:
if not color_mode:
return c
r, g, b = c[0], c[1], c[2]
except:
if color_mode == bits:
return c
if bits == 16:
br, bg, bb = 5, 6, 5
else:
br, bg, bb = 8, 8, 8
r, g, b = c & (2**br - 1) * 2**(8 - br), c & ((2**bg - 1) * 2**br) // 2**br * 2**(8 - bg), c & ((2**bb - 1) * 2**(br + bg)) // 2**(br + bg) * 2**(8 - bb)
if not color_mode:
return (r, g, b)
else:
if color_mode == 16:
br, bg, bb = 5, 6, 5
else:
br, bg, bb = 8, 8, 8
r, g, b = r // 2**(8 - br), g // 2**(8 - bg) * 2**br, b // 2 **(8 - bb) * 2**(br + bg)
c = r + g - (r & g)
return c + b - (c & b)
Voici de quoi tracer des lignes verticales et horizontales :
- Code: Tout sélectionner
def draw_vline(x, y1, y2, c):
for j in range(y2 - y1 + 1):
set_pixel(x, y1 + j, c)
def draw_hline(y, x1, x2, c):
for j in range(x2 - x1 + 1):
set_pixel(x1 + j, y, c)
Et voici enfin notre code de tracé de la mire :
- Code: Tout sélectionner
#o: 0=horizontal, 1=vertical
#s: 0=no_shadow, 1=shadow left/up, -1=shadow right/down
def mire(w, h, y0=0, s=1, o=0):
if o:
l1, l2, f, i1, i2 = h, w, draw_hline, y0, 0
else:
l1, l2, f, i1, i2 = w, h, draw_vline, 0, y0
n = 8
for m in range(l1):
v = 255
if s != 0:
v = v * (s*m % l1) // (l1 - 1)
for j in range(n):
f(m + i1, j * l2 // n + i2, (j + 1) * l2 // n - 1 + i2, fixcolor(color8(j, v)))
def color8(j, v):
c = [0, 0, 0]
for b in range(3):
if j & 2**b:
c[b] = v
return c
Tu vas vite comprendre tout ça avec notre premier exemple.
Commençons donc par les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition que nous allons tester en Python.Nous considérerons que c'est pareil sur les anciennes TI-83 Premium CE et TI-84 Plus CE, ainsi que sur la nouvelle TI-82 Advanced Edition Python.
Ici les fonctions relatives aux pixels sont
ti_graphic.getPixel(x,y) et ti_graphic.setPixel(x,y,couleur). Nous disposons comme déjà vu d'une zone graphique utile en Python de 320×210 pixels, accessibles à partir de y=30.Cela ne t'apprendra sans doute rien mais histoire de vérifier que ça marche, d'après get_color_mode() sur TI-83 Premium CE Edition Python et TI-84 Plus CE Python Edition les couleurs de pixels sont codées en Python par des tuples (r,g,b).
mire(320,240,30). On peut noter que le vert ainsi que les couleurs composées de vert (cyan, jaune et blanc) ont un dégradé beaucoup moins saccadé, beaucoup plus fluide. En effet si tu regardes bien elles utilisent 2 fois plus de teintes intermédiaires, très exactement 64 teintes contre 32 pour les autres :- canal rouge sur 5 bits pour 25= 32 teintes
- canal vert sur 6 bits pour 26= 64 teintes
- canal bleu sur 5 bits pour 25= 32 teintes
Voici maintenant la Casio Graph 90+E et son superbe écran.Les fonctions relatives aux pixels à utiliser sont
casioplot.get_pixel(x,y) et casioplot.set_pixel(x,y,couleur). Nous disposons comme déjà vu en Python d'une zone graphique utile de 384×192 pixels.Ici encore les paramètres de couleur sont passés sous forme de tuples (r,g,b).
Appelons donc mire(384,192). Même constat ici, nous notons 2 fois plus de teintes intermédiaires pour les dégradés de vert et de couleurs incluant du vert :- canal rouge sur 5 bits pour 25= 32 teintes
- canal vert sur 6 bits pour 26= 64 teintes
- canal bleu sur 5 bits pour 25= 32 teintes
Arrive maintenant la NumWorks.Les fonctions de pixels sont
kandinsky.get_pixel(x,y) et kandinsky.set_pixel(x,y,couleur). Avec l'application Python officielle, les paramètres de couleur prennent toujours la forme de tuples (r,g,b). La zone graphique utile en Python est ici de 320×222 pixels.
mire(320,222). Encore pareil, 2 fois plus de teintes intermédiaires dans le vert :- canal rouge sur 5 bits pour 25= 32 teintes
- canal vert sur 6 bits pour 26= 64 teintes
- canal bleu sur 5 bits pour 25= 32 teintes
Passons donc aux TI-Nspire CX II testables en Python.Nous considérerons le résultat représentatif des anciennes TI-Nspire CX et TI-Nspire CM.
Les fonctions relatives aux pixels à utiliser sont
ti_image.get_pixel(x,y) et ti_image.set_pixel(x,y,couleur). Nous disposons comme déjà vu en Python d'une zone graphique utile de 318×212 pixels.Ici encore les paramètres de couleur sont passés sous forme de tuples (r,g,b).
mire(318,212). Toujours 2 fois plus de teintes intermédiaires tirant sur le vert :- canal rouge sur 5 bits pour 25= 32 teintes
- canal vert sur 6 bits pour 26= 64 teintes
- canal bleu sur 5 bits pour 25= 32 teintes
Sur les anciennes TI-Nspire monochromes, le langage interprété ne dispose hélas pas des fonctions de tracé.
Adaptons donc notre mire dans le langage de script Lua :
Sur les TI-Nspire monochromes nous avons donc 4 bits pour 24= 16 niveaux de gris.
Adaptons donc notre mire dans le langage de script Lua :
- Code: Tout sélectionner
o = false
s = 1
function on.charIn(c)
print(c)
olds, oldo = s, o
if c == "−" or c == "-" then
s = -1
elseif c == "+" then
s = 1
elseif c == "0" then
s = 0
elseif c == "*" or c == "/" then
o = not o
end
if s ~= olds or o ~= oldo then
platform.window.invalidate()
end
end
function on.resize(w, h)
platform.window.invalidate()
end
function color8(j, v)
l={0, 0, 0}
for k = 1, #l do
if math.floor(j / 2^(k - 1)) % 2 ~= 0 then
l[k] = v
end
end
return l
end
function on.paint(gc)
pw = platform.window
w, h = pw.width(), pw.height()
if o then
l1, l2 = h, w
function f(gc, y, x1, x2, c)
gc:setColorRGB(c[1], c[2], c[3])
gc:drawRect(x1, y, x2, y)
end
else
l1, l2 = w, h
function f(gc, x, y1, y2, c)
gc:setColorRGB(c[1], c[2], c[3])
gc:drawRect(x, y1, x, y2)
end
end
n = 8
for m = 0, l1 - 1 do
v = 255
if s ~=0 then
v = v * (s * m % l1) / (l1 - 1)
end
for j = 0, n - 1 do
f(gc, m, j * l2 / n, (j + 1)*l2/n - 1, color8(j, v))
end
end
end
Sur Casio fx-CP400+E nous ne pouvons hélas pas te programmer de mire. 
En effet dans le langage interprété historique de la machine et seul langage qui nous est accessible, le paramètre de couleur des fonctions graphiques ne peut prendre que 7 valeurs différentes.
Toujours le même résultat avec 2 fois plus de teintes intermédiaires dans les tons de vert :
- canal rouge sur 5 bits pour 25= 32 teintes
- canal vert sur 6 bits pour 26= 64 teintes
- canal bleu sur 5 bits pour 25= 32 teintes
On peut remarquer un petit bug d'affichage dans le dégradé de bleu, comme si la teinte la plus claire avait été marquée en tant que couleur transparente.Mais ce n'est pas un bug lié à notre convertisseur, nous obtenons exactement le même défaut en utilisant le logiciel de conversion officiel de Casio.
Et enfin nous arrive la HP Prime. Nous y bénéficions en Python d'une formidable zone graphique de 320×240 pixels.
Le module Python hpprime nous offre de quoi écrire un pixel :
pixon(numero_calque,x,y,couleur).Il ne fournit pas directement de quoi lire un pixel, mais par contre une fonction
eval() permettant de faire appel au langage constructeur HPPPL où cette fonction existe. On peut alors se redéfinir une fonction get_pixel() en Python :- Code: Tout sélectionner
def get_pixel(x, y):
return int(eval("get_pixel(" + str(x) + "," + str(y) + ")"))
Ici c'est ainsi fantastique, l'appel mire(320,240) nous fournit des dégradés extrêmement fluides et ce peu importe la teinte ! - canal rouge sur 8 bits pour 28= 256 teintes
- canal vert sur 8 bits pour 28= 256 teintes
- canal bleu sur 8 bits pour 28= 256 teintes
Ces nouvelles mesures sont dès maintenant disponibles dans nos tableaux, ainsi que pour les modèles plus anciens :
