Forum TI-Planet.org

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 !

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.

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.

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).

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 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

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 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

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.

Appelons mire(320,222). Encore pareil, 2 fois plus de teintes intermédiaires dans le vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

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).

Appelons donc mire(318,212). Toujours 2 fois plus de teintes intermédiaires tirant sur le vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 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

Sur les TI-Nspire monochromes nous avons donc 4 bits pour 2⁴= 16 niveaux de gris.

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.

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 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

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.