![](https://i.imgur.com/YDsUVHf.png?1)
![5409](https://cdn.ti-planet.org/forum/gallery/image.php?mode=thumbnail&image_id=5409)
Pour fêter les 10 ans de
TI-Planet en cette rentrée 2021, nous te publions la base de données intégrale de nos classements de rentrée
QCC organisés depuis la rentrée 2015.
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)
Ce qui donne pas moins de
136 modèles différents de calculatrices testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic !
![:D :D](./images/smilies/grin.png)
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 :
- 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 :
- 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: Select all
#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: Select all
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: Select all
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: Select all
#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.
![:) :)](./images/smilies/smile.png)
![](https://i.imgur.com/BHLl6ftt.png)
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).
![](https://i.imgur.com/GAFEF47t.png)
![12795](https://cdn.ti-planet.org/forum/gallery/image.php?mode=thumbnail&image_id=12795)
Voici donc ci-contre l'affichage de l'appel associé
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
Total donc
16 bits pour
216= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565.
![](https://i.imgur.com/Ea5z6Gxt.png)
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).
![12826](https://cdn.ti-planet.org/forum/gallery/image.php?mode=thumbnail&image_id=12826)
![](https://i.imgur.com/NIXmm6ft.png)
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
Total donc
16 bits pour
216= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565.
![](https://i.imgur.com/suZtIxHt.png)
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.
![](https://i.imgur.com/WqnEKeIt.png)
![12836](https://cdn.ti-planet.org/forum/gallery/image.php?mode=thumbnail&image_id=12836)
Appelons
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
Total donc
16 bits pour
216= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565.
![](https://i.imgur.com/lJfISKbt.png)
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).
![](https://i.imgur.com/4tjCKo4t.png)
![12857](https://cdn.ti-planet.org/forum/gallery/image.php?mode=thumbnail&image_id=12857)
Appelons donc
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
Total donc
16 bits pour
216= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565.
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 :
- Code: Select all
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
![](https://i.imgur.com/v4SxWPkt.png)
![12869](https://cdn.ti-planet.org/forum/gallery/image.php?mode=thumbnail&image_id=12869)
Sur les
TI-Nspire monochromes nous avons donc
4 bits pour
24= 16 niveaux de gris.
![](https://i.imgur.com/6m3hrmFt.png)
Sur
Casio fx-CP400+E nous ne pouvons hélas pas te programmer de mire.
![:'( :'(](./images/smilies/crying.png)
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.
![Pas bien! :mj:](./images/smilies/sg3agmjg3ag.gif)
![](https://i.imgur.com/v8NLjaBt.png)
![12871](https://cdn.ti-planet.org/forum/gallery/image.php?mode=thumbnail&image_id=12871)
Alors plan B, générons et enregistrons notre mire sous forme d'image, et convertissons-la en image
.c2p pour la calculatrice à l'aide de notre
convertisseur en ligne.
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
Total donc
16 bits pour
216= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 565.
![](https://i.imgur.com/0uLwcYht.png)
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.
![](https://i.imgur.com/EQHilMdt.png)
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: Select all
def get_pixel(x, y):
return int(eval("get_pixel(" + str(x) + "," + str(y) + ")"))
![12882](https://cdn.ti-planet.org/forum/gallery/image.php?mode=thumbnail&image_id=12882)
![](https://i.imgur.com/XD4Mn2Rt.png)
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 !
![:D :D](./images/smilies/grin.png)
- 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
Total donc
24 bits pour
224= 16777216 couleurs affichables, et un contrôleur écran fonctionnant donc au format
RGB 888 !
![Géant! :#tritop#:](./images/smilies/123.gif)
Ces nouvelles mesures sont dès maintenant disponibles dans nos tableaux, ainsi que pour les modèles plus anciens :