π
<-
Chat plein-écran
[^]

QCC 2021 Universel épisode 8: écrans et profondeurs

QCC 2021 Universel épisode 8: écrans et profondeurs

Message non lude critor » 20 Aoû 2021, 12:45

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 8 - Écrans et profondeurs

5409Pour 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

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
1149712780

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
12588716611396

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

12795Voici 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.

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

12826Appelons 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.

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.

12836Appelons 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.

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

12857Appelons 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: 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

12869Sur les TI-Nspire monochromes nous avons donc 4 bits pour 24= 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. :mj:

12871Alors 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.

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) + ")"))


12882Ici 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
  • 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 ! :#tritop#:

Ces nouvelles mesures sont dès maintenant disponibles dans nos tableaux, ainsi que pour les modèles plus anciens :
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.8%
 
Messages: 41465
Images: 14479
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor

Re: QCC 2021 Universel épisode 8: écrans et profondeurs

Message non lude bebertii » 20 Aoû 2021, 14:38

Les 65536 couleurs de la Numworks ne semblent pas une surprise : https://www.numworks.com/fr/ressources/ ... kandinsky/
Avatar de l’utilisateur
bebertii
Niveau 2: MI2 (Membre Initié)
Niveau 2: MI2 (Membre Initié)
Prochain niv.: 93.3%
 
Messages: 11
Inscription: 09 Fév 2016, 11:23
Genre: Non spécifié
Calculatrice(s):
MyCalcs profile
Classe: prof de physique

Re: QCC 2021 Universel épisode 8: écrans et profondeurs

Message non lude critor » 20 Aoû 2021, 15:37

Oui je sais, merci. Mais dans la mesure du possible, je revérifie tout par moi-même.

C'est peut-être moins vrai chez NumWorks, mais chez la concurrence la communication technique lorsque existante n'est pas toujours d'une parfaite exactitude.
C'est donc une habitude que j'ai prise en conséquence, afin de ne pas diffuser des bêtises ou imprécisions.
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.8%
 
Messages: 41465
Images: 14479
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor


Retourner vers News Divers

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 47 invités

-
Rechercher
-
Social TI-Planet
-
Sujets à la une
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
Phi NumWorks jailbreak
123
-
Faire un don / Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...
Faire un don
Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partenaires et pub
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
1683 utilisateurs:
>1664 invités
>14 membres
>5 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Autres sites intéressants
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)