π
<-
Chat plein-écran
[^]

QCC 2021 Universel épisode 8: écrans et profondeurs

QCC 2021 Universel épisode 8: écrans et profondeurs

Unread postby critor » 20 Aug 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: 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)
.

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

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: Select all
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
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 19.5%
 
Posts: 38373
Images: 11134
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti
GitHub: critor

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

Unread postby bebertii » 20 Aug 2021, 14:38

Les 65536 couleurs de la Numworks ne semblent pas une surprise : https://www.numworks.com/fr/ressources/ ... kandinsky/
User avatar
bebertii
Niveau 2: MI2 (Membre Initié)
Niveau 2: MI2 (Membre Initié)
Level up: 66.7%
 
Posts: 9
Joined: 09 Feb 2016, 11:23
Gender: Not specified
Calculator(s):
Class: prof de physique

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

Unread postby critor » 20 Aug 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
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 19.5%
 
Posts: 38373
Images: 11134
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti
GitHub: critor


Return to News Divers

Who is online

Users browsing this forum: No registered users and 12 guests

-
Search
-
Social
-
Featured topics
Concours de rentrée 2021 - La Geste d'Alrys
Concours de rentrée 2021 - Synchro-donjon !
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Remplace ton ancienne fx-92 Collège ou Graph 35 par la nouvelle Graph 35+E II programmable en Python ! Pour tout achat d'une nouvelle Graph 35 d'ici le 30 septembre 2021, Casio te rembourse 10€. En cas de retour de ta fx-92 Collège c'est 18€, et même ou 23€ si tu retournes ton ancienne Graph 35. Etiquette de retour fournie, pas de frais de port à payer, même les anciens modèles et machines non fonctionnelles sont acceptées. En partenariat avec les Restos du cœur.
Remplace ton ancienne fx-92 Collège ou Graph 35 par la Graph 90+E couleur. Pour tout achat, Casio te rembourse 10€ en cas de retour de ta fx-92 Collège, ou 15€ en cas de retour de ta Graph 35. Etiquette de retour fournie, pas de frais de port à payer, même les anciens modèles et machines non fonctionnelles sont acceptées. En partenariat avec les Restos du coeur.
10€ remboursés par Casio sur l'achat de ta calculatrice Graph 35 d'ici le 30 Septembre 2021
Reprise de ton ancienne fx-92 Collège à 5€ ou Graph 35 à 10€. Même non fonctionnelle ou ancien modèle. Etiquette de retour fournie, pas de frais de port à payer. En partenariat avec les Restos du coeur.
25€ remboursés par Casio sur l'achat de ta calculatrice fx-CP400 d'ici le 31 Octobre 2021
3€ remboursés par Casio sur l'achat de ta calculatrice fx-92 Collège d'ici le 30 Septembre 2021
Casio Graph 90+E ou Graph 35+E II avec couvercle personnalisé à gagner sur simple participation aux formations Casio de Septembre 2021.
Disque dur externe + écouteurs bluetooth + 2 superbes coques personnalisées pour Graph 90+E ou Graph 35+E II à gagner en répondant d'ici le 24 Septembre 2021 à la question : "Quelle est l'unité de tension électrique ?"
Coque NumWorks édition limitée Septembre 2021 à gagner.
123456789101112
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
672 utilisateurs:
>643 invités
>23 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)

-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)