π
<-
Chat plein-écran
[^]

News 2021
May (3)
April (3)
March (1)

News 2020
August (15)
July (2)
June (7)
May (7)
April (19)
March (4)

News 2019
August (4)
July (7)
June (6)
May (1)
April (3)
March (1)

News 2018
August (11)
July (8)
June (3)
May (10)
April (2)
March (4)

News 2017
August (15)
July (18)
June (1)
May (7)
April (4)
March (7)

News 2016
August (17)
July (16)
June (2)
May (2)
April (1)
March (5)

News 2015
August (25)
July (1)
June (4)
May (9)
April (4)
March (10)

News 2014
August (4)
July (4)
June (11)
May (12)
April (9)
March (12)
January (13)

News 2013
October (11)
August (5)
July (5)
June (9)
May (12)
April (10)
March (7)
January (10)

News 2012
August (12)
July (10)
June (13)
May (22)
April (8)
March (5)

News 2011
October (23)
August (1)
July (7)
June (29)
May (11)
April (5)
March (3)

News 2010
August (2)
July (2)
June (5)

News 2009
August (1)
July (1)
June (1)
May (1)
April (1)
March (1)

img2calc: conversion image → Python toutes calculatrices

New postby critor » Today, 11:13

Dans une série d'articles précédents nous te présentions , notre service en ligne gratuit sur
TI-Planet
te permettant de convertir tes images pour ta calculatrice.

Etaient donc gérés de nombreux formats d'images pour tes programmes
Basic
:
  • .8ca
    ou
    .8ci
    pour
    TI-83 Premium CE
    et
    TI-84 Plus CE
  • .8xi
    ,
    .83i
    ,
    .82i
    ,
    .73i
    ,
    .85i
    ou
    .86i
    pour les
    TI-83 Plus
    (compatible
    TI-84 Plus
    et
    TI-82 Plus
    )
    ,
    TI-83
    (compatible
    TI-82 Stats
    et
    TI-76.fr
    )
    ,
    TI-82
    ,
    TI-73
    ,
    TI-85
    et
    TI-86
  • pour
    Casio fx-CP400
    et
    fx-CG500
  • pour
    Casio Graph 90+E
    et
    fx-CG50/20/10

Etait également géré le cas très particulier du format spécifique aux scripts
Python
TI-83 Premium CE
et
TI-84 Plus CE
.

Si tu programmais en
Python
sur une machine autre qu'une
TI-83 Premium CE
et
TI-84 Plus CE
, jusqu'à présent
img2calc
n'était donc pas en mesure de t'aider à incorporer des images. :'(

Pas possible donc de te lancer dans des projets
Python
graphiques ambitieux sans te taper au préalable toute l'étude du codage et de la compression d'images.

13917Sur
TI-Planet
il y a de grands jours et de très grands jours... ;)

Voici aujourd'hui une mise à jour majeure de
img2calc
te permettant de convertir les images de ton choix pour tes scripts
Python
sur calculatrices, et cette fois-ci pour l'ensemble des modèles ! :bj:

Un nouveau sélecteur
Mode
t'est proposé à cette fin en haut de la page de l'outil, permettant donc au choix de générer :
  • comme jusqu'à présent une ressource image à appeler par un programme
    Basic
    ou
    Python
  • ou maintenant directement du code
    Python
    à incorporer dans tes scripts

En cliquant donc sur ce dernier onglet tu obtiens le bel éventail de bibliothèques
Python
de tracé par pixels supportées : :D
  • ti_draw
    (
    TI-Nspire CX II
    )
  • graphic
    (
    TI-Nspire CX II
    avec
    KhiCAS
    ,
    TI-Nspire CX
    avec
    KhiCAS
    et
    NumWorks
    avec
    KhiCAS
    )
  • nsp
    (
    TI-Nspire
    avec )
  • ti_graphics
    (
    TI-83 Premium CE
    et
    TI-84 Plus CE
    éditions
    Python
    )
  • casioplot
    (
    Casio Graph 90/35+E II
    ,
    fx-9750/9860GIII
    et
    fx-CG50
    )
  • hpprime
    (
    HP Prime
    )
  • kandinsky
    (
    NumWorks
    )

Le convertisseur te produit un script
Python
, aussi bien téléchargeable que visualisable en coloration syntaxique sur la page en question, et directement utilisable avec :
  • le codage de ton image
  • une fonction prête à l'emploi permettant d'afficher ton image à la position de ton choix :bj:
  • un exemple d'utilisation
Le codage se veut optimisé en taille afin de permettre sur la plupart des modèles des affichages d'images plein écran, ce qui n'est pas incompatible avec des optimisations en performances bien au contraire comme nous allons voir ! :D

Non non, tu ne rêves pas, quelque soit ton cursus ou ton niveau tu peux dès maintenant obtenir des images directement prêtes à l'emploi pour tes jeux, interfaces ou projets
Python
sur ta calculatrice ; plus aucune limite à ton imagination ou ta créativité ! :bj:


C'est un travail intensif qui nous a conduits à ce résultat. Nous allons tenter de t'expliciter les différents choix faits pour les scripts générés.





1) Compactage des données image

Go to top

Prenons pour le moment quelque chose de très simple. Supposons donc que tu souhaites afficher l'image
15×15
pixels ci-contre dans un de tes scripts
Python
.

Un premier codage très naïf dit
true color
de ton image pourrait alors ressembler à ça :
Code: Select all
image = [
[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],
[255,255,255],[255,255,255],[255,255,255],[255,255,255],[054,111,159],[255,255,255],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[255,255,255],[255,255,255],[255,255,255],[255,255,255],
[255,255,255],[255,255,255],[255,255,255],[255,255,255],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[255,255,255],[255,255,255],[255,255,255],[255,255,255],
[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[255,255,255],[255,255,255],[255,255,255],[255,255,255],
[255,255,255],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[255,255,255],[255,255,255],[255,255,255],[255,255,255],
[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[255,255,255],[255,204,062],[255,204,062],[255,255,255],
[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[054,111,159],[255,255,255],[255,255,255],[255,204,062],[255,204,062],[255,204,062],
[054,111,159],[054,111,159],[054,111,159],[054,111,159],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,204,062],[255,204,062],[255,204,062],[255,204,062],
[054,111,159],[054,111,159],[054,111,159],[255,255,255],[255,255,255],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],
[255,255,255],[054,111,159],[054,111,159],[255,255,255],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],
[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,255,255],
[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],
[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,255,255],[255,255,255],[255,255,255],[255,255,255],
[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,255,255],[255,204,062],[255,255,255],[255,255,255],[255,255,255],[255,255,255],
[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,204,062],[255,255,255],[255,255,255],[255,255,255],[255,255,255],[255,255,255],
]

Il s'agit donc d'une liste des couleurs de pixels, de gauche à droite puis de haut en bas, les couleurs étant codées en triplets de valeurs Rouge-Vert-Bleu, l'implémentation la plus fréquente sur calculatrices.

Ce premier codage est toutefois catastrophique en terme de consommation mémoire.

Commençons par expliciter de quoi l'on parle. Les interpréteurs
MicroPython
ou similaires qui tournent sur nos calculatrices font appel à différents types de mémoires :
  • La mémoire de stockage, qui contient physiquement tes scripts prêts à l'emploi.
  • La pile
    (
    stack
    )
    qui référence, à l'exécution, les objets
    Python
    créés. Sa capacité limite donc le nombre d'objets
    Python
    pouvant coexister simultanément en mémoire.
  • Le tas
    (
    heap
    )
    qui stocke, à l'exécution, le contenu des objets
    Python
    créés. Il limite donc la taille globale utilisée pour les données de ces différents objets.
Voici quelques consommations
heap
valides pour les plateformes 32 bits que sont à ce jour nos calculatrices :
  • pour un entier :
    24
    octets de base +
    4
    octets si non nul +
    4
    octets pour chaque groupe de 30 bits utilisés au-delà des premiers 31 bits dans sa représentation binaire
  • pour une liste :
    56
    octets de base +
    8
    octets par élément + les tailles de chaque élément
Comme tu peux le constater le langage
Python
a le très gros défaut d'être un énorme consommateur de mémoire
heap
. Cette mémoire sera très souvent le facteur limitant lors de tes projets
Python
sur calculatrices, et il faut donc y faire très attention.

Ce premier codage consomme donc
$mathjax$56+15\times 15\times\left(8+56+3\times\left(8+28\right)\right)$mathjax$
soit
38,756 Ko
de
heap
.

Rappelons donc les capacités
heap
des différentes solutions
Python
sur calculatrices :
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,068 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E
  5. 101,262 Ko
    :
    Casio Graph 35+E II
  6. 33,582 Ko
    :
    NumWorks
  7. 18,354 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 4,100 Mo
    :
    TI-Nspire CX
  4. 2,068 Mo
    :
    TI-Nspire CX II
  5. 1,033 Mo
    :
    Casio Graph 90+E
  6. 101,262 Ko
    :
    Casio Graph 35+E II
  7. 98,928 Ko
    :
    NumWorks
    (firmware Omega)
  8. 64,954 Ko
    :
    NumWorks N0110
    (firmware Delta / Omega + appli KhiCAS)
  9. 33,582 Ko
    :
    NumWorks
  10. 25,235 Ko
    :
    NumWorks N0110
    (firmware Delta)
  11. 18,354 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,068 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  5. 101,262 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  6. 33,582 Ko
    :
    NumWorks
  7. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  8. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 4,100 Mo
    :
    TI-Nspire CX / CX II
  4. 2,068 Mo
    :
    TI-Nspire CX II
  5. 2,050 Mo
    :
    TI-Nspire
  6. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  7. 258,766 Ko
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (SH4 - appli CasioPython)
  8. 101,262 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  9. 98,928 Ko
    :
    NumWorks
    (firmware Omega)
  10. 64,954 Ko
    :
    NumWorks N0110
    (firmware Omega + appli KhiCAS)
  11. 33,582 Ko
    :
    NumWorks
  12. 32,648 Ko
    :
    Casio Graph 35+E II / 35/75/85/95
    (SH3)
    / fx-9750/9860GIII / fx-9750/9860GII
    (SH3)
    / fx-9860G
    (appli CasioPython)
  13. 25,235 Ko
    :
    NumWorks N0110
    (firmware Delta)
  14. 23,685 Ko
    :
    TI-83 Premium CE + TI-Python
  15. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  16. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition

Et oui, codée de cette façon cette pauvre image de
15×15
pixels génère déjà une erreur de mémoire à l'exécution sur ta
TI-83 Premium CE
ou ta
NumWorks
munie du
firmware
officiel.

Si l'image n'a pas vocation à être modifiée pendant l'exécution de ton script
Python
, au lieu d'utiliser des listes on peut penser à utiliser des tuples. Un tuple s'utilise exactement comme une liste, la seule différence étant que son contenu n'est plus altérable après création.

Le tuple a l'avantage d'occuper un peu moins de place en
heap
qu'une liste :
  • pour une liste :
    56
    octets de base +
    8
    octets par élément + les tailles de chaque élément
  • pour un tuple :
    40
    octets de base +
    8
    octets par élément + les tailles de chaque élément
Une différence très légère certes, mais loin d'être négligeable lorsque comme ici on a affaire à une liste de listes. ;)

Nouvelle version donc :
Code: Select all
image = (
(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),
(255,255,255),(255,255,255),(255,255,255),(255,255,255),(054,111,159),(255,255,255),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(255,255,255),(255,255,255),(255,255,255),(255,255,255),
(255,255,255),(255,255,255),(255,255,255),(255,255,255),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(255,255,255),(255,255,255),(255,255,255),(255,255,255),
(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(255,255,255),(255,255,255),(255,255,255),(255,255,255),
(255,255,255),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(255,255,255),(255,255,255),(255,255,255),(255,255,255),
(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(255,255,255),(255,204,062),(255,204,062),(255,255,255),
(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(054,111,159),(255,255,255),(255,255,255),(255,204,062),(255,204,062),(255,204,062),
(054,111,159),(054,111,159),(054,111,159),(054,111,159),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,204,062),(255,204,062),(255,204,062),(255,204,062),
(054,111,159),(054,111,159),(054,111,159),(255,255,255),(255,255,255),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),
(255,255,255),(054,111,159),(054,111,159),(255,255,255),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),
(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,255,255),
(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),
(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,255,255),(255,255,255),(255,255,255),(255,255,255),
(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,255,255),(255,204,062),(255,255,255),(255,255,255),(255,255,255),(255,255,255),
(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,204,062),(255,255,255),(255,255,255),(255,255,255),(255,255,255),(255,255,255),
)


Cette fois-ci l'exécution de ce code consomme
$mathjax$40+15\times 15\times\left(8+40+3\times\left(8+28\right)\right)$mathjax$
soit
35,140 Ko
de
heap
, un gain d'environ 9,33%.
Toujours pas suffisant toutefois pour espérer pouvoir afficher cette pauvre icône sur
TI-83 Premium CE
ou
NumWorks
...

Mais c'est bête donc de repréciser à chaque fois le tuple de couleur, alors qu'il n'y a ici que 3 couleurs différentes dans notre image, non ? ;)

L'étape d'optimisation suivante est d'externaliser les informations de couleurs dans une palette, ce que l'on appelle une image indexée :
Code: Select all
palette = ((255,255,255), (054,111,159), (255,204,062))

image = (
0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,
0,0,0,0,1,0,1,1,1,1,1,0,0,0,0,
0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,
0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,
0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,
1,1,1,1,1,1,1,1,1,1,1,0,2,2,0,
1,1,1,1,1,1,1,1,1,1,0,0,2,2,2,
1,1,1,1,0,0,0,0,0,0,0,2,2,2,2,
1,1,1,0,0,2,2,2,2,2,2,2,2,2,2,
0,1,1,0,2,2,2,2,2,2,2,2,2,2,2,
0,0,0,0,2,2,2,2,2,2,2,2,2,2,0,
0,0,0,0,2,2,2,2,0,0,0,0,0,0,0,
0,0,0,0,2,2,2,2,2,2,2,0,0,0,0,
0,0,0,0,2,2,2,2,2,0,2,0,0,0,0,
0,0,0,0,0,2,2,2,2,2,0,0,0,0,0,
)


Cela n'occupe plus que
$mathjax$40+3\times\left(8+40+3\times\left(8+28\right)\right)+40+15\times 15\times\left(8+28\right)$mathjax$
soit
8,648 Ko
de
heap
. Un formidable gain d'environ 75,39%, notre icône est dès maintenant fonctionnelle sur tous les modèles ! :bj:
Toutefois c'est juste
15×15
pixels, nous t'avons promis des images plein écran, il y a encore du travail à faire... ;)

Une autre optimisation pour améliorer le format serait de regrouper plusieurs nombres entiers en un seul.

En effet, les valeurs sont toutes petites, et nous avons vu que les valeurs entières de
1
jusqu'à 2**30-1 soit
1073741823
occupaient de toutes façons la même taille. Que de place gâchée...

C'est une solution que nous avons déjà expérimentée pour les scripts de notre concours de rentrée 2020, et nous ne souhaitons pas la creuser ici.

Si elle permet des gains significatifs en consommation mémoire, elle complexifie fortement l'accès aux données qui sont alors ici à extraire d'un grand nombre entier par opérations binaires, et cela se fait donc au détriment des performances.

Passons plutôt directement à autre chose, la chaîne de caractères. En voici la consommation
heap
:
  • pour un tuple :
    40
    octets de base +
    8
    octets par élément + les tailles de chaque élément
  • pour une chaîne :
    49
    octets de base +
    1
    octet par caractère
À vide la chaîne occupe un peu plus de place en mémoire qu'un tuple, mais elle progresse beaucoup moins en taille au fur et à mesure de l'ajout des éléments.

Voici un codage en ce sens :
Code: Select all
palette = ((255,255,255), (054,111,159), (255,204,062))

image = (
"\x00\x00\x00\x00\x00\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x01\x00\x01\x01\x01\x01\x01\x00\x00\x00\x00"
"\x00\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x01\x01\x01\x01\x00\x00\x00\x00"
"\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00"
"\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x02\x02\x00"
"\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x02\x02\x02"
"\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x02\x02\x02\x02"
"\x01\x01\x01\x00\x00\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02"
"\x00\x01\x01\x00\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02"
"\x00\x00\x00\x00\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x00"
"\x00\x00\x00\x00\x02\x02\x02\x02\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x02\x02\x02\x02\x02\x02\x02\x00\x00\x00\x00"
"\x00\x00\x00\x00\x02\x02\x02\x02\x02\x00\x02\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x02\x02\x02\x02\x02\x00\x00\x00\x00\x00"
)

Une consommation
heap
ridicule qui n'est maintenant plus que de
$mathjax$40+3\times\left(8+40+3\times\left(8+28\right)\right)+49+15\times 15\times 1$mathjax$
soit
782
octets, un formidable gain d'encore environ 90,96% rien que par rapport au codage précédent ! :#tritop#:

On peut aller encore un tout petit peu plus loin avec un dernier type,
bytes
.

Les variables de type
bytes
s'utilisent comme des chaînes, mais à la différence sont optimisées pour le stockage d'octets
(la où les chaînes stockent des caractères, et les caractères spéciaux peuvent occuper plusieurs octets)
.

Voici la différence en
heap
:
  • pour une chaîne :
    49
    octets de base +
    1
    octet par caractère
  • pour un
    bytes
    :
    33
    octets de base +
    1
    octet par octet

Et voici le codage ainsi modifié, pas bien compliqué :
Code: Select all
palette = ((255,255,255), (054,111,159), (255,204,062))

image = (
b"\x00\x00\x00\x00\x00\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x01\x00\x01\x01\x01\x01\x01\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x00\x00\x00\x01\x01\x01\x01\x00\x00\x00\x00"
b"\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00"
b"\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x02\x02\x00"
b"\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x02\x02\x02"
b"\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x02\x02\x02\x02"
b"\x01\x01\x01\x00\x00\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02"
b"\x00\x01\x01\x00\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02"
b"\x00\x00\x00\x00\x02\x02\x02\x02\x02\x02\x02\x02\x02\x02\x00"
b"\x00\x00\x00\x00\x02\x02\x02\x02\x00\x00\x00\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x02\x02\x02\x02\x02\x02\x02\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x02\x02\x02\x02\x02\x00\x02\x00\x00\x00\x00"
b"\x00\x00\x00\x00\x00\x02\x02\x02\x02\x02\x00\x00\x00\x00\x00"
)

Une consommation
heap
qui baisse très légèrement à
$mathjax$40+3\times\left(8+40+3\times\left(8+28\right)\right)+33+15\times 15\times 1$mathjax$
soit
766
octets.

Cela peut paraître négligeable, mais opter pour le type
bytes
ici adapté sur-mesures à ce que l'on fait devrait également avoir un impact sur les performances. ;)

Et voilà, avec ce dernier codage indexé en
bytes
et jusqu'à présent sans le moindre effort algorithmique, nous avons économisé 98,02% par rapport au codage initial
true color
.

img2calc
convertit donc tes images sous la forme de
bytes
accompagnés d'une palette.




2) Compression des données image

Go to top

Nous allons mettre en œuvre maintenant une compression. La compression
RLE
est justement particulièrement bien adaptée aux images indexées que nous avons ici.

Selon un parcours de l'image de gauche à droite puis de haut en bas, cette compression accompagne chaque indication de couleur du nombre de pixels adjacents qui l'utilisant.

Par exemple avec notre image d'exemple, cela donne :
Code: Select all
0(×5) 1(×5) 0(×9)
1(×1) 0(×1) 1(×5) 0(×8)
1(×7) 0(×11)
1(×4) 0(×5)
1(×10) 0(×4)
1(×11) 0(×1) 2(×2) 0(×1)
1(×10) 0(×2) 2(×3)
1(×4) 0(×7) 2(×4)
1(×3) 0(×2) 2(×10)
0(×1) 1(×2) 0(×1) 2(×11)
0(×4) 2(×10) 0(×5)
2(×4) 0(×11)
2(×7) 0(×8)
2(×5) 0(×1) 2(×1) 0(×9)
2(×5) 0(×5)

En prenant chacun de ces 43 blocs de couleur codé sur 2 octets
(1 pour la couleur et 1 pour le nombre de pixels concerné)
cela nous donnerait ici
$mathjax$40+3\times\left(8+40+3\times\left(8+28\right)\right)+33+43\times 2\times 1$mathjax$
soit plus que
627
octets.

Mais nous allons nous montrer encore un peu plus malins que ça. Nous choisissons le codage suivant permettant de stocker couleurs et longueurs dans le même octet :
  • la couleur codée de façon variable sur 1 à 8 bits selon la taille de la palette, permettant donc un maximum de
    256
    couleurs différentes
  • le dernier bit si non utilisé pour la couleur afin d'indiquer de prendre en compte l'octet suivant dans le compte des pixels
  • les bits restants
    (incluant donc éventuellement l'octet suivant)
    pour indiquer le nombre de pixels adjacents partageant cette même couleur
Comme nous n'avons ici que 3 couleurs, la couleur est codée sur 2 bits, ce qui laisse alors 5 bits pour coder la longueur sur le même octet. Aucun bloc ne dépassant ici les 32 pixels de large, tous les blocs sont ainsi codables sur 1 seul octet ! :bj:

Nous avons donc
$mathjax$40+3\times\left(8+40+3\times\left(8+28\right)\right)+33+43\times 1\times 1$mathjax$
soit
584
octets, un gain final de 98,49% par rapport au codage initial ! :bj:

Un gros avantage niveau performances de la compression par blocs
RLE
est justement que cela amène naturellement à allumer les lignes de pixels ainsi décrites via des appels
fill_rect()
, beaucoup plus rapides que des boucles d'appels de
set_pixel()
.

Bien évidemment à condition qu'une fonction
fill_rect()
soit fournie par la bibliothèque graphique concernée. C'est le cas de presque toutes les bibliothèques, seule
casioplot
fait hélas exception à ce jour.

Cela ne nous servira pas pour des images de fond d'écran aujourd'hui, mais nous nous réservons également le droit d'avoir 1 couleur transparente dans la palette. Cela pourrait être utile pour l'affichage de certains
sprites
dans tes jeux. ;)

Voici la fonction de tracé d'image codée en ce sens :
Code: Select all
#the image drawing function
#- rle : image RLE-compressed data
#- w : width of image
#- pal : palette of colors to use with image
#- itransp : index of 1 transparent color in palette or -1 if none
def draw_image(rle, x0, y0, w, pal, itransp=-1):
  i, x = 0, 0
  x0, y0 = int(x0), int(y0)
  nvals = len(pal)
  nbits = 0
  nvals -= 1
  while(nvals):
    nvals >>= 1
    nbits += 1
  maskval = (1 << nbits) - 1
  maskcnt = (0xFF >> nbits >> 1) << nbits
  while i<len(rle):
    v = rle[i]
    mv = v & maskval
    c = (v & maskcnt) >> nbits
    if (v & 0b10000000 or nbits == 8):
      i += 1
      c |= rle[i] << (7 - nbits + (nbits == 8))
    while c:
      cw = min(c, w - x)
      if mv != itransp:
        set_color(pal[mv])
        fill_rect(x0 + x, y0, cw, 1)
      c -= cw
      x = (x + cw) % w
      y0 += x == 0
    i += 1




3) Bibliothèques de tracé par pixels et caractéristiques

Go to top

Avant d'aller plus loin, détaillons les caractéristiques et capacités des différentes bibliothèques gérées par notre convertisseur, soit :
  • les dimensions de la zone graphique que l'on contrôle
  • le format de paramètre couleur et son affichage
  • les possibilités d'optimisation de l'affichage en
    double buffering
    ou
    multiple buffering
  • la présence d'une fonction
    fill_rect()
  • et les différentes adaptations que cela nécessite dans la boucle while c: de la fonction
    draw_image()
    précédente
C'est parti :
  • ti_graphics
    /
    TI-83 Premium CE
    et
    TI-84 Plus CE
    éditions
    Python
    :
    320×210
    pixels, couleurs
    (R8,G8,B8)
    affichées en
    RGB-565
    , pas de
    double buffering
    , fonction fillRect(x, y, largeur, hauteur)
    Code: Select all
    setColor(pal[mv])
    fillRect(x0 + x, y0, cw, 1)
  • ti_draw
    /
    TI-Nspire CX II
    :
    318×212
    pixels, couleurs
    (R8,G8,B8)
    mais affichées en
    RGB-565
    ,
    double buffering
    optionnel, fonction fill_rect(x, y, largeur, hauteur)
    Code: Select all
    set_color(pal[mv])
    fill_rect(x0 + x, y0, cw, 1)
  • hpprime
    /
    HP Prime
    :
    320×240
    pixels, couleurs
    RGB-888
    ,
    multiple buffering
    optionnel, fonction fillrect(calque, x, y, largeur, hauteur, couleur_exterieur, couleur_interieur)
    Code: Select all
    fillrect(calque, x0 + x, y0, cw, 1, pal[mv], pal[mv])
  • casioplot
    /
    Casio Graph 90+E
    et
    fx-CG50
    :
    384×192
    pixels, couleurs
    (R8,G8,B8)
    mais affichées en
    RGB-565
    ,
    double buffering
    , fonction fill_rect(x, y, largeur, hauteur)
    Code: Select all
    col = pal[mv]
    x1 = x0 + x
    for k in range(cw):
      set_pixel(x1 + k, y0, col)
  • casioplot
    /
    Casio Graph 35+E II
    et
    fx-9750/9860GIII
    :
    128×64
    pixels, couleurs
    (R8,G8,B8)
    mais affichées en noir et blanc, fonction fill_rect(x, y, largeur, hauteur),
    double buffering

    Code: Select all
    col = pal[mv]
    x1 = x0 + x
    for k in range(cw):
      set_pixel(x1 + k, y0, col)
  • kandinsky
    /
    NumWorks
    :
    320×222
    pixels, couleurs
    (R8,G8,B8)
    affichées en
    RGB-565
    , pas de
    double buffering
    , fonction fill_rect(x, y, largeur, hauteur, couleur)
    Code: Select all
    fill_rect(x0 + x, y0, cw, 1, pal[mv])
  • graphic
    /
    TI-Nspire CX II
    +
    KhiCAS
    ,
    TI-Nspire CX
    +
    KhiCAS
    et
    NumWorks
    +
    KhiCAS
    :
    320×222
    pixels, couleurs
    (R8,G8,B8)
    affichées en
    RGB-565
    , pas de
    double buffering
    , fonction draw_filled_rectangle(x, y, largeur, hauteur, couleur)
    Code: Select all
    fill_rect(x0 + x, y0, cw, 1, pal[mv])
  • nsp
    /
    TI-Nspire CX
    + :
    320×240
    pixels, couleurs
    RGB-565
    ,
    multiple buffering
    , pas de fonction
    fill_rect()

    Code: Select all
    col = pal[mv]
    x1 = x0 + x
    for k in range(cw):
      calque.setPx(x1 + k, y0, col)
  • nsp
    /
    TI-Nspire
    + :
    320×240
    pixels, couleurs
    RGB-565
    mais affichées en noir et blanc,
    multiple buffering
    , pas de fonction
    fill_rect()

    Code: Select all
    col = pal[mv]
    x1 = x0 + x
    for k in range(cw):
      calque.setPx(x1 + k, y0, col)




4) Tailles et performances

Go to top

Afin de mieux illustrer les gains, changeons d'image d'exemple. Nous t'avions donc promis des affichages plein écran dignes de jeux vidéo, en voici justement une. ;)

Notre image dépasse ici les 256 couleurs, et seules 256 couleurs seront donc conservées pour la palette par l'outil de conversion. La compression utilisera donc ici 8 bits pour le codage de la couleur, et donc systématiquement 2 octets par bloc.

13912C'est donc parti avec la
TI-Nspire CX II
et sa bibliothèque
ti_draw
gérant
318×212
pixels.

La variable
image
occupe
110,217 Ko
en mémoire, un jeu d'enfant pour les
2,068 Mo
de
heap
de cette machine ! :bj:

Voici le prototype du script généré :
Code: Select all
from ti_draw import fill_rect, set_color

def draw_image(rle, x0, y0, w, pal, itransp=-1):
  ...

palette = ( ... )
image = ( ... )

#image drawing code sample
from ti_draw import use_buffer, paint_buffer
use_buffer()
draw_image(image, 0, 0, 318, palette, -1)
paint_buffer()

Le code d'exemple fourni active ici le
double buffering
à des fins de rapidité en encadrant ces appels graphiques d'appels
use_buffer()
et
paint_buffer()
, te permettant cet affichage plein écran en
1min 13s
selon la mesure du module
time
.

Pour référence si l'on n'utilise pas ces appels, le même affichage prend
3mins 19,72s
. Le
double buffering
semble donc ici permettra une accélération d'un facteur d'environ 2,75.
Dans les deux cas c'est très décevant mais pas forcément surprenant, les bibliothèques fournies par
TI
étant rarement connues pour leur optimisation en performances.

Une autre piste serait d'exploiter la bibliothèque dédiée propriétaire
ti_image
, mais cela nécessiterait la gestion du format de fichier
.tns
ce qui n'est pas chose aisée. Donc pour l'instant, convertir des images pour une utilisation avec
ti_image
n'est possible qu'avec le logiciel
TI-Nspire CX
payant.

13919La bibliothèque
casioplot
des
Casio Graph 90+E
et
fx-CG50
gère pour sa part
384×192
pixels.

Avec la variable
image
qui occupe
118,199 Ko
en mémoire, ici encore c'est facile comme bonjour pour les
1,033 Mo
de
heap
de la calculatrice ! :bj:

Voici un schéma du code :
Code: Select all
from casioplot import set_pixel

def draw_image(rle, x0, y0, w, pal, itransp=-1):
  ...

palette = ( ... )
image = ( ... )

#image drawing code sample
from casioplot import show_screen
draw_image(image, 0, 0, 384, palette, -1)
show_screen()

Précisons que le convertisseur prend la peine ici de ne pas mettre plus de 256 caractères par ligne, l'interface de la calculatrice refusant d'ouvrir les scripts avec des lignes plus longues
(mais acceptant quand même de les exécuter)
.

Cela ne suffit toutefois pas à rendre le code visualisale sur calculatrice puisqu'il y a une autre limite allègrement dépassée avec l'image choisie ici, l'interface refuse également d'ouvrir les scripts dépassant les 300 lignes.

Ici pas d'appels
fill_rect()
puisque n'existant pas, mais des boucles de
set_pixel()
.
Ce lourd handicap n'empêche pas la
Casio Graph 90+E
d'écraser complètement les
TI-Nspire CX II
avec ici un affichage en seulement
18s
environ ! :bj:
(mesuré aproximativement au chronomètre, le module
time
étant ici absent)

13918Restons chez
Casio
avec maintenant les
Graph 35+E II
,
fx-9750GIII
et
fx-9860GIII
. Même bibliothèque
casioplot
mais ici limitée à
128×64
pixels.

Toutefois l'écran étant ici monochrome, le convertisseur limite la palette à 2 couleurs
(l'implémentation
Python
de
Casio
ne gérant de toutes façons pas les niveaux de gris)
. Ceci permet le codage
RLE
des couleurs sur seulement 1 bit et ainsi une compression fantastique, la variable
image
n'occupant que
593
octets ! Avec
101,262 Ko
de
heap
, tu as même largement ici de quoi animer ton fond d'écran ! :bj:

Le script ne risquant pas de dépasser les 300 lignes avec une variable
image
aussi petite, le code est cette fois-ci visualisable et éditable directement depuis la calculatrice. :bj:

Code: Select all
from casioplot import set_pixel

def draw_image(rle, x0, y0, w, pal, itransp=-1):
  ...

palette = ( ... )
image = ( ... )

#image drawing code sample
from casioplot import show_screen
draw_image(image, 0, 0, 128, palette, -1)
show_screen()


L'affichage plein écran est ici encore plus rapide, dans les
1,5s
! :D

13911Passons maintenant à
KhiCAS
, logiciel intégré de Mathématiques et Sciences installable sur
TI-Nspire CX II
et
TI-Nspire CX
.
KhiCAS
intègre un interpréteur
Micropython
avec sa propre bibliothèque de tracé par pixels,
graphic
.

graphic
travaille en
320×222
pixels. La variable
image
occupe ici
115,159 Ko
, ce qui en théorie ne cause donc strictement aucun problème aux
4,100 Mo
de
heap
que permet
KhiCAS
sur ces machines.

Voici un résumé du code généré :
Code: Select all
from graphic import fill_rect

def draw_image(rle, x0, y0, w, pal, itransp=-1):
  ...

palette = ( ... )
image = ( ... )

#image drawing code sample
draw_image(image, 0, 0, 320, palette, -1)

Le convertisseur évite ici que des lignes dépassent les 43000 caractères et quelques, sans quoi cela bloque
KhiCAS
.

Le module
time
est ici présent mais ne travail qu'en secondes, estimant donc dans les
3s
pour l'affichage.
Cela n'est reste pas moins formidable, révélant ainsi toute la véritable puissance de la machine ! :D

Cela confirme donc au passage que le problème de performances des
TI-Nspire CX II
vu plus haut venait bien de l'implémentation du module
ti_draw
officiel comme supposé.

Passons maintenant sur
NumWorks
avec 2 bibliothèques travaillant toujours en
320×222
pixels :
  • kandinsky
    , la bibliothèque officielle
  • et
    graphic
    , ici encore la bibliothèque de
Toujours
115,159 Ko
donc, ce qui ne rentre en aucun cas dans le
heap
de la machine
(
98,928 Ko
avec le firmware tiers ,
64,954 Ko
avec ,
33,582 Ko
avec le firmware officiel)
.

Pour te tester ça malgré tout, il va donc nous falloir dégrader l'image. Nous pouvons au choix :
  • en réduire les dimensions
  • réduire le nombre de couleurs utilisées, ce qui a un effet direct sur le taux de compression
    RLE
    , puisque davantage de pixels adjaçants se mettent alors à utiliser la même couleur
T'ayant promis des images plein écran pour des jeux, nous choisissons cette dernière solution.

On pourrait penser qu'il suffirait juste de supprimer quelques couleurs pour que cela marche déjà avec le
firmware
... Mais non, en fait le
heap
n'est même pas le facteur limitant ici, il y en a un autre... :#roll#:

En effet, la calculatrice ne dispose dans tous les cas que d'une capacité de mémoire de stockage absolument ridicule face à toute la concurrence, seulement
32 Kio
. Avec tous ses codages hexadécimaux sur 4 caractères, notre script les explose très largement.

13915En fait il nous faut ici descendre de 256 à
3
couleurs afin d'obtenir un script occupant moins de 32 Kio en mémoire de stockage. En conséquence la consommation
heap
de la variable
image
est ridicule, ici
6,793 Ko
.

Voici un abrégé du code généré :
Code: Select all
from kandinsky import fill_rect

def draw_image(rle, x0, y0, w, pal, itransp=-1):
  ...

palette = ( ... )
image = ( ... )

#image drawing code sample
draw_image(image, 0, 0, 320, palette, -1)

Code: Select all
from graphic import fill_rect

def draw_image(rle, x0, y0, w, pal, itransp=-1):
  ...

palette = ( ... )
image = ( ... )

#image drawing code sample
draw_image(image, 0, 0, 320, palette, -1)

L'affichage prend ici
6,445s
, mais la comparaison aux autres modèles n'est pas pertinente puisque le nombre de couleurs réduit implique un nombre de blocs restreint, et donc beaucoup moins d'appels à
draw_line()
pour remplir l'écran.

Après même si c'est regrettable d'être ainsi bridé pour des images plein écran, la solution
img2calc
reste librement utilisable pour incorporer des
sprites
dans tes jeux. ;)

13916Passons à la
HP Prime
et sa bibliothèque
hpprime
permettant de contrôler cette fois-ci tous les
320×240
pixels de l'écran.

La variable image occupe ici
122,573 Ko
, ce qui n'est qu'une pauvre goutte d'eau dans l'océan des
252,1 Mo
de
heap
de la
HP Prime G2
. Tu as ici de quoi jouer littéralement des cinématiques dans tes jeux
Python
! :bj:

Voici le schéma du code :
Code: Select all
from kandinsky import fill_rect

def draw_image(rle, x0, y0, w, pal, itransp=-1):
  ...

palette = ( ... )
image = ( ... )

#image drawing code sample
draw_image(image, 0, 0, 320, palette, -1)

Code: Select all
from hpprime import fillrect

def draw_image(layer, rle, x0, y0, w, pal, itransp=-1):
  ...

palette = ( ... )
image = ( ... )

#image drawing code sample
from hpprime import eval
draw_image(0, image, 0, 0, 320, palette, -1)
eval("wait()")


Pas de module
time
ici, mais le chromètre donne dans les
1,64s
, absolument fantastique ! :bj:

Enfin, terminons avec les éditions
Python
des
TI-83 Premium CE
et
TI-84 Plus CE
.

La bibliothèque
ti_graphics
permet d'allumer jusqu'à
320×210
pixels.

Encore un problème de taille ici autre que le
heap
: les scripts
Python
que l'on transfère à la calculatrice ne peuvent en aucun cas dépasser les
64 Kio
.

Mais ce n'est pas tout, car l'application
Python
refuse systématiquement de se lancer si elle détecte des scripts
Python
dépassant les
51,2 Ko
.

13913C'est une fois ces deux contraintes respectées qu'il faut se préoccuper de la capacité absolument ridicule du
heap
de la machine, seulement
18,354 Ko
.

Donc pas le choix, ici encore il nous faut réduire à 3 couleurs... La variable image occupe alors
6,467 Ko
de
heap
, à rajouter bien sûr à la consommation de la palette ainsi qu'à celle de l'importation du module
ti_graphics
.

Voici le principe du code :
Code: Select all
from ti_graphics import fillRect, setColor

def draw_image(rle, x0, y0, w, pal, itransp=-1):
  ...

palette = ( ... )
image = ( ... )

#image drawing code sample
from ti_system import disp_wait
draw_image(image, 0, 30, 320, palette, -1)
disp_wait()


En plus d'être grand consommateur de
heap
, l'affichage est ici très lent,
7mins 21s
mesurées au module
time
, et encore qu'est-ce que ça aurait été avec 256 couleurs comme sur les autres machines...

13914Dans le cas de ces calculatrices, tu ferais mieux d'opter pour la solution propriétaire dédiée du format , également gérée par
img2calc
.

Cela te permet de sortir les données images de ton script
Python
, et ainsi de supprimer complètement la barrière du
heap
.

Et par conséquent plus de problème de taille de script non plus ici, tu peux bénéficier de l'ensemble des 256 couleurs en seulement
0,606s
! :bj:




5) Liens d'accès

Go to top

Pour accéder à
img2calc
dès maintenant, c'est très simple. Outre une entrée dédiée dans la liste des convertisseurs au menu de
TI-Planet
, tu as 2 liens directs dont un court :

Jeu-concours enseignants Calcuso & TI avec 5000€ de lots !

New postby critor » 10 May 2021, 13:36

Jusqu'au
10 juin 2021
inclus,
Calcuso
, distributeur scolaire de calculatrices et accessoires
Casio
,
Hewlett Packard
,
NumWorks
,
Sharp
et
Texas Instruments
, organise un grand jeu concours.

La participation est ouverte à l'ensemble des enseignants en Sciences dans un lycée de France métropolitaine, île de Beauté incluse.

127243 gros lots t'ont été très généreusement constitués en partenariat avec
Texas Instruments
:
  1. lot
    classe
    d'une valeur de
    4383€
    :
    35
    calculatrices
    TI-83 Premium CE Edition Python
    accompagnées chacune de l'ensemble des accessoires et options qui font la signature de
    Calcuso
    :
  2. lot
    télétravail
    d'une valeur de
    479€
    :
    tablette graphique
    XP Pen Deco 03
    accompagnée ici encore de nombre d'accessoires :
    • webcam
      Full HD Logitech C922 Pro Stream
    • casque stéréo sans fil
      Jabra Evolve 65
    • support pour ordinateur
      Fatorm
      10-17"
    • anneau lumineux
      LAVKOW
      16cm
    • microphone
      Blue Snowball Black iCE
    • enceinte portable
      KATMAI E7-L
    • clef
      USB
      Texas Instruments
    • carnet
      Texas Instruments
    L'idéal pour l’enseignement à distance ; la tablette graphique est un bel outil pour les Mathématiques, notamment pour écrire, corriger ou montrer des formules. De plus, la webcam, le casque stéréo sans fil, l’anneau lumineux, le microphone, le haut-parleur portable et le support pour ton ordinateur feront de toi un expert de la visioconférence ! :D
  3. lot
    enseignant
    d'une valeur de
    382€
    :
    calculatrice graphique
    Texas Instruments
    au choix, accompagnée de :
    • robot pilotable
      TI-Innovator Rover
    • interface
      TI-Innovator Hub
    • TI-Innovator Breadboard pack
    • comme ci-dessus, tous les accessoires
      Calcuso
      mais correspondant au modèle de calculatrice choisi
    Le meilleur de la technologie
    Texas Instruments
    ; l'écosystème
    TI-Innovator
    permet d'étendre les fonctionnalités des calculatrices
    Texas Instruments
    . De quoi donner une dimension concrète et ludique à la programmation ainsi qu'aux concepts mathématiques, et les rendre accessible à tous dans le cadre de projets
    STEM
    ! :D
    9049129127592

Pour participer et tenter de gagner c'est très simple, il te suffit de remplir le formulaire lié ci-dessous d'ici le
10 juin 2021
avant minuit, avec :
  • tes informations professionnelles
  • le gros lot que tu souhaites gagner, car oui c'est toi qui choisis ;)
Et pas de perdant, tu gagnes directement
25%
de réduction sur l'intégralité du catalogue
Calcuso
! :bj:

Lien de participation
:
https://docs.google.com/forms/d/e/1FAIp ... w/viewform

Offre TI aide équipement établissements - rentrée 2021

New postby critor » 05 May 2021, 12:03

Enseignant ?
Texas Instruments
lance son offre d'aide à l'équipement pour la rentrée 2021, à l'attention des collèges et lycées de France métropolitaine, DOM, et AEFE.

Pour en bénéficier, il suffit que ton établissement scolaire recommande l'achat de calculatrices
Texas Instruments
ou organise un achat groupé de calculatrices
Texas Instruments
, et ce de façon
exclusive
aux promotions d'élèves entrantes
(c'est-à-dire pour l'ensemble des classes de Sixième, des classes de Seconde ou Première selon la politique du lycée, et des classes de première année de BTS ou CPGE)
.

Tu as jusqu'au
30 novembre 2021
inclus pour remplir le formulaire de participation et joindre ton justificatif.

Le justificatif pourra être au choix la liste de fournitures scolaires et/ou lettre de rentrée à l'attention des familles, ou encore la facture d'achat groupé, le tout bien évidemment visé conforme par le chef d'établissement.

Devra donc y figurer au choix la mention de calculatrice(s)
Texas Instruments
, et à l'exclusion bien sûr de toute marque de calculatrices concurrente. :#non#:

11506Mais dans le cadre d'un achat groupé cela ne devrait pas être bien difficile, aucune obligation donc d'engager l'ensemble de tes collègues du lycée cette année ! :bj:

En récompense de cette fidélité, tu pourras recevoir 1 produit gratuit au choix et ce pour chaque tranche de 30 élèves concernés ! :bj:
Cette année tu as l'embarras du choix avec pas mal de nouveautés et exclusivités : :D
  • 1
    calculatrice graphique formelle
    TI-Nspire™ CX II-T CAS
  • 1
    calculatrice graphique exacte
    TI-Nspire™ CX II-T
  • 1
    licence logiciel
    TI-Nspire™ CX Premium
    (édition enseignant pour
    Windows
    /
    Mac
    )

    11325
  • 1
    calculatrice graphique semi-exacte
    (QPiRac)
    TI-83 Premium CE Edition Python
  • 1
    calculatrice graphique semi-exacte
    (QPiRac)
    TI-82 Advanced Edition Python
  • 1
    licence logiciel
    TI-SmartView™ CE
    (émulateur de
    TI-83 Premium CE Edition Python
    à installer sur
    Windows/Mac
    )
  • 1
    clé
    USB TI-SmartView™ CE 5.5
    (émulateur permanent
    TI-83 Premium CE Edition Python
    utilisable sous
    Windows/Mac
    sans installation ni licence - si tu disposes déjà d'une de ces clés USB dans une ancienne version, tu pourras la mettre à jour gratuitement en version
    5.5
    et es donc libre de choisir autre chose)

    72889049
  • 1
  • 1
  • 1
    TI-Innovator I/O Module Pack
    (pack de 1 capteur + 3 actionneurs
    Grove
    : capteur de lumière, servomoteur, moteur à vibration, et LED blanche)

    75847588758975907591

    121327512
  • 1
    sonar
    (capteur de distance)
    + 1
    TI-RGB Array
    (rampe de 16 diodes RGB)

    12502
  • 1
    cahier d'activités
    Python
    Eyrolles

  • 1
    calculatrice scientifique semi-exacte
    (QPiRac)
    TI-Collège Plus Solaire
  • 1
    licence logiciel
    TI-SmartView™
    (émulateur de
    TI-Collège Plus Solaire
    à installer sur
    Windows/Mac
    )
Du matériel qui pourra donc être conservé de façon mutualisée pour être utilisé par les enseignants, prêté ponctuellement à des élèves ayant cassé/perdu leur machine, des élèves dans le besoin ou encore pour des projets d'élèves, donné en récompense à des élèves méritants
(s'étant illustrés lors de concours, olympiades, rallyes ou tout simplement dans leur investissement scolaire)
... les possibilités ne manquent pas ! :D

Mais quelle générosité, merci
Texas Instruments
! :favorite:

Lien
:
https://education.ti.com/fr/enseignants ... r-programs

Mise à jour 1.5 pour TI-Innovator Hub et nouveautés

Postby critor » 07 Apr 2021, 11:22

12212Depuis des années maintenant,
Texas Instruments
réalise de gros efforts pour rendre la programmation de ses calculatrices accessible à toutes et tous. Le constructeur a prêté une attention toute particulière aux plus jeunes et non initiés, souhaitant leur permettre de créer tous les projets
STEM / STIM
imaginables sans avoir à se concentrer sur des difficultés annexes. :)

L'interface te permet de transformer ta calculatrice
TI-83 Premium CE
ou
TI-Nspire CX
en une machine connectée ouverte sur le monde. Elle intègre un capteur de luminosité, une diode
RVB
, ainsi qu'un
buzzer
. Mais en plus de cela, l'interface permet de connecter des modules externes
(capteurs et actionneurs)
sur ses ports
Grove
, ou selon tes besoins sur son port
breadboard
.

Texas Instruments
propose également plusieurs kits de démarrage :

Le
TI-Innovator Hub
permet également la connexion de plusieurs périphériques officiels :
Tous ces éléments ont de plus l'avantage d'être utilisables directement avec le langage
Python
des calculatrices concernées, faisant de l'écosystème
Texas Instruments
le seul
Python
connecté ! :bj:

13698Très exactement en même temps que les mises à jour et la semaine dernière,
Texas Instruments
a publié une mise à jour pour le
TI-Innovator Hub
.

Ce dernier passe de la version
1.4
à la version
1.5
, de numérotation complète
1.5.0.49
.

La version
1.5
est une mise à jour majeure qui apporte de nouvelles options, commandes et même capteurs ; nous allons te détailler tout ça.

Nous avons toutefois été bien surpris de cette publication simultanée, les menus des
TI-Nspire CX
restant inchangés dans leur dernière version et ne présentant donc pas ces nouveautés, ni en
TI-Basic
ni en
Python
. Si tu souhaites les exploiter tu devras donc les saisir intégralement à la main.

7577Soucieux de mettre à la portée de chacun les projets les plus évolués tout en minimisant le nombre de notions prérequises à travailler,
Texas Instruments
avait déjà rajouté un paramètre optionnel
BLINK
aux commandes de diode, permettant de les faire clignoter sans avoir à faire une boucle enchaînant les commandes d'allumage/extinction avec les bons délais :
Code: Select all
SET LIGHT ON BLINK <fréquence>
SET LED <numéro> ON BLINK <fréquence>
SET COLOR <valeur_rouge> <valeur_vert> <valeur_bleu> BLINK <fréquence>
SET COLOR.RED <valeur> BLINK <fréquence>
SET COLOR.GREEN <valeur> BLINK <fréquence>
SET COLOR.BLUE <valeur> BLINK <fréquence>
SET RV.COLOR <valeur_rouge> <valeur_vert> <valeur_bleu> BLINK <fréquence>
SET RV.COLOR.RED <valeur> BLINK <fréquence>
SET RV.COLOR.GREEN <valeur> BLINK <fréquence>
SET RV.COLOR.BLUE <valeur> BLINK <fréquence>
SET ANALOG.OUT <numéro> <valeur> BLINK <fréquence>
SET DIGITAL.OUT <numéro> <valeur> BLINK <fréquence>
SET VIB.MOTOR <numéro> ON BLINK <fréquence>

De façon très similaire
Texas Intruments
rajoute un paramètre optionnel comparable aux commandes de son,
TEMPO
, permettant ici de hacher la sortie audio et donc d'émettre des bips. Le paramètre
TEMPO
prend pour valeur une fréquence, c'est-à-dire le nombre de bips par seconde :
Code: Select all
SET SOUND <fréquence_son> TEMPO <fréquence_bips>
SET SPEAKER <numéro> <fréquence_son> TEMPO <fréquence_bips>

Par exemple :
  • émettre un son à 440 Hz à 2 bips par seconde pendant 5 secondes sur le
    buzzer
    interne :
    SET SOUND 440 TEMPO 2 TIME 5
  • émettre un son à 880 Hz à 3 bips par seconde pendant 4 secondes sur le haut-parleur externe n°1 :
    SET SPEAKER 1 880 TEMPO 3 TIME 4
Notons qu'un paramètre de 0 désactive l'option
TEMPO
. C'est-à-dire que les 2 commandes suivantes sont équivalentes, émettant dans les deux cas un son continu à 400 Hz pendant 5 secondes :
Code: Select all
SET SOUND 400 TIME 5 TEMPO 0
SET SOUND 400 TIME 5

Des nouveautés dans la gestion des modules
Grove
externes
DHT
, capteurs numériques de température et humidité. Ces capteurs
Grove
existent en 2 versions aux spécifications très différentes :
  • le
    DHT11
    :
    • températures de 0°C à 50°C avec une marge d'erreur de ±2°C
    • humidité de 20% à 90% avec une marge d'erreur de ±5%
  • le
    DHT22
    :
    • températures de -40°C à 80°C avec une marge d'erreur de ±0,5°C
    • humidité de 5% à 99% avec une marge d'erreur de ±2%
Comme tu le vois le
DHT11
est une version basique assez limité, ne fonctionnant notamment pas en-dessous de 0°C, alors que le
DHT22
est une version bien plus professionnelle.

Dans le cas d'un capteur
DHT
, la commande d'interrogation dispose d'un nouveau paramètre permettant maintenant de récupérer le type du capteur :
READ DHT <numéro> TYPE
La commande retournera les valeurs suivantes :
  • 1
    pour un
    DHT11
  • 2
    pour un
    DHT22

Nouveau paramètre également pour récupérer l'état d'un capteur
DHT
et gérer d'éventuelles erreurs :
READ DHT <numéro> STATUS
La commande retournera les valeurs suivantes :
  • 1
    si tout est bon
  • 2
    en cas d'erreur
    timeout
  • 3
    en cas d'erreur de somme de contrôle

Ces 2 informations sont de plus également récupérées lors d'une interrogation générique du capteur :
READ DHT <numéro>
On obtient ici une liste avec dans l'ordre :
  • température
  • humidité
  • type
  • état

90497512Du nouveau également avec les sonars
(ranger en anglais, soit capteurs de distance)
.

Dans le cas d'un capteur de type sonar, la commande d'interrogation accepte un nouveau paramètre optionnel,
TIME
. Celui-ci permet de récupérer non pas la distance calculée, mais le temps de vol, soit la durée entre le début de l'émission de l'onde sonore et sa réception.

C'est valable aussi bien avec les sonars
Grove
à connecter qu'avec le sonar intégré au
TI-Innovator Rover
:
Code: Select all
READ RANGER <numéro> TIME
READ RV.RANGER TIME

De nouvelles possibilités d'exploration et investigation lors des TP en conséquence.

Fantastique, la version
1.5
active un nouveau capteur déjà intégré à ton
TI-Innovator Hub
, sans avoir besoin de modifier ou racheter ce dernier !

Il s'agit d'une horloge. Elle part de 0 à l'allumage et augmente avec le temps. Pour l'interroger c'est très simple :
READ TIMER

Tu as donc également maintenant de quoi synchroniser tes projets, leur faire tenir compte du temps écoulé.

Grande innovation permettant de minimiser le nombre de lignes de code dans tes projets, il est maintenant possible de commander simultanément jusqu'à 4 actionneurs grâce au connecteur logique
AND
:
Par exemple, émet un son à 440 Hz pendant 2 secondes + allume la diode RVB en mauve pendant 2 secondes :
SET SOUND 440 TIME 2 AND COLOR 255 0 255 TIME 2

Les commandes ainsi composées peuvent même se terminer de façon indépendante :
  • allume la diode RVB en mauve + émet un son à 440 Hz pendant 2 secondes :
    SET COLOR 255 0 255 AND SOUND 440 TIME 2
  • émet un son à 440 Hz pendant 2 secondes + allume la diode RVB en mauve pendant 4 secondes :
    SET SOUND 440 TIME 2 AND COLOR 255 0 255 TIME 4
Au-delà de la simple minimisation du nombre de lignes de code, c'est aussi une façon de corriger le léger problème de décalage. En effet lorsque l'on souhaitait déclencher 2 actions en même temps, on n'avait pas d'autre choix que d'utiliser 2 lignes de commande. Elles n'étaient donc pas exécutées en même temps mais avec un léger décalage, qui selon les projets pouvait être bien gênant.

Niveau lecture de capteurs nous avons des nouveautés comparables. Toujours dans le but à la fois de minimiser les imbrications de boucles nécessaires dans les programmes de l'utilisateur, et d'améliorer la pertinence des mesures. Ici cela se passe avec une nouvelle commande,
COLLECT
.

Déjà, il devient possible de récupérer toute une série de mesures d'une simple commande. Plus besoin de s'embêter à faire des boucles et surtout à les synchroniser correctement.

Par exemple :
  • lis le capteur de température numéro 1 pendant 5 secondes à 4 échantillons par seconde :
    Code: Select all
    COLLECT TEMPERATURE 1 TIME 5 RATE 4
    READ LIST TEMPERATURE 1
  • lis le capteur de température numéro 1 pendant 10 secondes à 10 échantillons par seconde :
    Code: Select all
    COLLECT TEMPERATURE 1 TIME 10 RATE 10
    READ LIST TEMPERATURE 1
  • lis le capteur de luminosité intégré pendant 5 secondes à 5 échantillons par seconde :
    Code: Select all
    COLLECT BRIGHTNESS TIME 5 RATE 5
    READ LIST BRIGHTNESS
  • lis le capteur de luminosité intégré pendant 10 secondes à 8 échantillons par seconde :
    Code: Select all
    COLLECT BRIGHTNESS TIME 10 RATE 8
    READ LIST BRIGHTNESS

En prime pour tracer un diagramme le plus exact possible ou tout simplement tenir compte de la pertinence de la série de mesures, après la lecture il est possible de récupérer les valeurs horloge associées à chaque échantillon, et donc de tenir compte de la régularité de l'échantillonnage :
READ LIST TIME

Et surtout encore une fois pour grandement te simplifier la vie et tes projets, le connecteur logique
AND
te permet d'interroger jusqu'à 4 capteurs simultanément.

Par exemple, lis le capteur de pression Vernier numéro 1 et les température+humidité du DHT numéro 1, et les dates de mesure pendant 10 secondes à 4 échantillons par seconde :
Code: Select all
COLLECT VERNIER 1 AND DHT 1 TIME 10 RATE 4
READ LIST VERNIER 1
READ LIST DHT1 TEMPERATURE
READ LIST DHT1 HUMIDITY
READ TIME

Bien que les commandes
READ
soient exécutées de façon successive, en fait l'échantillonnage démarre dès la commande
COLLECT
et met les résultats en mémoire cache. Tu récupéreras donc bien 4 listes de même taille, avec leurs éléments correspondants mesurés au même moment.

La commande
AVERAGE
te permettait déjà de préciser pour chaque capteur analogique, le nombre de mesures à effectuer avant de retourner une valeur. Cela permet de réduire les erreurs dues au bruit et d'améliorer la pertinence des mesures à traiter :
AVERAGE <capteur> <valeur>

Nouveauté donc, nous avons maintenant une nouvelle commande
AVERAGING
permettant le même réglage mais de façon globale à l'ensemble des capteurs analogiques :
AVERAGING <valeur>

Après un réglage
AVERAGING
tu conservers toujours la possibilité de préciser des valeurs différentes pour certains capteurs avec
AVERAGE
, à condition de le faire avant la commande de connexion
CONNECT
de chaque capteur concerné.

12132Le
TI-RGB Array
t'offre une grille de diodes
RVB
adressables numérotées de 0 à 15. Dans son cas, jusqu'à présent tu devais allumer les diodes adressables une par une, ce qui là encore générait des décalages cumulés dans leur allumage, ce qui n'était pas toujours du plus bel effet et même bien gênant pour certains projets :
SET RGB <numéro_diode> <valeur_rouge> <valeur_vert> <valeur_bleu

Désormais tu peux allumer simultanément plusieurs diodes adressables selon la même couleur.

Par exemple, allume en mauve les 4 diodes de numéro 1, 3, 5 et 7 :
SET RGB [1 3 5 7] 200 0 200

L'ensemble des diodes à allumer peut également être précisé via un simple nombre décimal ou hexadécimal via l'option
PATTERN
:
  • SET RGB PATTERN 100 255 0 255
    Comme 100 se décompose en puissances de 2 selon
    $mathjax$64+32+4=2^6+2^5+2^2$mathjax$
    , allume en mauve les 3 diodes de numéros 2, 5 et 6.
  • SET RGB PATTERN 0X100 255 0 0
    Comme 0x100 c'est
    $mathjax$256=2^8$mathjax$
    , cela allume en rouge la diode numéro 8.

Téléchargements
:


Modules Grove/breadboard chez Calcuso/Jarrety

New postby critor » 03 Apr 2021, 09:36

12212Depuis des années maintenant,
Texas Instruments
réalise de gros efforts pour rendre la programmation de ses calculatrices accessible à toutes et tous. Le constructeur a prêté une attention toute particulière aux plus jeunes et non initiés, souhaitant leur permettre de créer tous les projets
STEM / STIM
imaginables sans avoir à se concentrer sur des difficultés annexes. :)

L'interface te permet de transformer ta calculatrice
TI-83 Premium CE
ou
TI-Nspire CX
en une machine connectée ouverte sur le monde. Elle intègre un capteur de luminosité, une diode
RVB
, ainsi qu'un
buzzer
. Mais en plus de cela, l'interface permet de connecter des modules externes
(capteurs et actionneurs)
sur ses ports
Grove
, ou selon tes besoins sur son port
breadboard
.

Texas Instruments
propose également plusieurs kits de démarrage :

Le
TI-Innovator Hub
permet également la connexion de plusieurs périphériques officiels :
Tous ces éléments ont de plus l'avantage d'être utilisables directement avec le langage
Python
des calculatrices concernées, faisant de l'écosystème
Texas Instruments
le seul
Python
connecté ! :bj:

12965Si tu préfères, à la place du
TI-Innovator Hub
tu peux également utiliser une carte
BBC micro:bit
qui permet elle aussi la connexion de modules
Grove
.

Les distributeurs scolaires de
Texas Instruments
pour la France,
Calcuso
,
Jarrety
et
TS Promotion
, avaient jusqu'à présent en catalogue les seuls éléments ci-dessus fournis par
Texas Instruments
.

Si tu avais besoin d'un module
Grove
ou
breadboard
plus original non inclus dans les kits de démarrage, il te fallait aller voir ailleurs.

Et bien bonne nouvelle. Pour cette rentrée 2021 plus besoin d'aller voir ailleurs,
Calcuso
et
Jarrety
innovent et rajoutent à leur catalogue plusieurs modules
Grove
et
breadboard
non présents dans les kits de démarrage ! :bj:

Tu peux dès maintenant aller jeter un coup d'œil à leur catalogue et comparer leurs prix. ;)

Liens
:
catalogue
STEM
chez
Calcuso
/
Jarrety
Link to topic: Modules Grove/breadboard chez Calcuso/Jarrety (Comments: 0)

Achat groupé TI : demande unifiée devis Calcuso/Jarrety/TSP

New postby critor » 02 Apr 2021, 11:32

Enseignant, envie d'équiper tes classes ou ton lycée en calculatrices graphiques
Texas Instruments
pour la rentrée 2021 ?

Envie de faire profiter tous les nouveaux entrants en Seconde de la nouvelle , une calculatrice couleur exacte programmable en
Python
, disponible chez
Calcuso
à moins de
65€
en achat individuel et sous conditions moins de
52€
en achat groupé ?

En Métropole, 3 grands distributeurs scolaires
Texas Instruments
étaient déjà à ta disposition pour cela :

Toutefois cela pouvait être embêtant d'avoir donc à soumettre 3 fois ta demande via des formulaires très différents afin d'obtenir les 3 devis à comparer, non ?

Et bien grande nouveauté pour cette rentrée 2021,
Texas Instruments
lance sur son site un outil unifié de demande de tarifs en ligne, bien évidemment sans engagement.

Tu n'as plus qu'un seul et unique formulaire à remplir avec l'adresse de l'établissement et le nombre de calculatrices souhaité pour chaque modèle.

Tu recevras alors automatiquement les devis des différents distributeurs scolaires, et tu n'auras plus qu'à les comparer pour retenir le plus intéressant. :bj:

Lien
:
Demander un devis des revendeurs scolaires TI

-
Search
-
Social
-
Featured topics
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Découvre les nouvelles fonctionnalités en Python de l'OS 5.2 pour les Nspire CX II
Découvre les nouvelles fonctionnalités en Python de l'OS 5.5 pour la 83PCE/84+C-T Python Edition
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
1234
-
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.
676 utilisateurs:
>643 invités
>27 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)