Concours de démos graphiques en Python
Posté le 21/04/2020 18:26
Salut à tous, chers programmeurs et avides de toutes choses stylées sur calculatrices. Vous êtes tous tombés au bon moment, car il est temps de jouer avec les nouveaux modules de dessin en Python ! 
Casio a récemment annoncé puis publié trois modules de rendu graphique en Python pour Graph 35+E II et Graph 90+E :
•
matplotl, une version minimale de matplotlib très fidèle à l'original.
•
turtle, une reproduction en règle parfaitement identique à l'original.
•
casioplot, un module bas-niveau pour modifier les pixels à l'écran avec des performances très intéressantes.
On a déjà
commencé à parler de ces modules en détails dans un article précédent, et on va continuer dans le futur. Pour l'instant, on peut résumer les nouveautés en quelques points !
• Les modules
matplotl et
turtle sont très conformes aux originaux, ce qui permet aux mêmes programmes de marcher sur calculatrice et sur PC. D'autres constructeurs comme Numworks ont fait ce choix, et sur Planète Casio on trouve ça génial.
• Le module
casioplot permet de faire du dessin très précis. Les performances ne permettent pas de faire du dessin en temps réel, mais on peut déjà faire pas mal de choses !
• Malheureusement, on n'a toujours rien pour interagir avec le clavier (
à part quelques essais avec AC/ON) donc on peut pas faire de jeux.
Ce qui nous amène au concours d'aujourd'hui. Pour lancer tout le monde sur le chemin de ces bibliothèques et découvrir tout ce qu'on peut faire de stylé avec, je vous propose un
concours de démos graphiques accessible à tous !
Qu'est-ce qu'une démo graphique ?
Une démo graphique, c'est un petit programme qui affiche des choses stylées à l'écran, pour démontrer les capacités graphiques d'une plateforme. Ça peut être des animations stylées, des choses colorées, des cubes en 3D... ça peut être une seule image, une animation, peu importe.
En gros si c'est beau et stylé, vous gagnez.
Voilà des exemples de démos graphiques que j'ai codées sur ma Graph 90+E. Celles-ci tournent en temps réel ! (Les captures ont été prises par un logiciel vidéo donc c'est bruité, ce n'est pas un effet du programme.)
Comme vous pouvez le voir, il y a plein de choses à faire, et vous pouvez vraiment vous lâcher !
Dates, fonctionnement, et lots du concours
Voilà comment ça va se passer. Vous avez
jusqu'au Samedi 9 Mai (un peu plus de 2 semaines) pour poster vos participations sur ce sujet. Pour participer, vous devez :
Poster sur ce sujet
une image ou animation de votre démo. Votre démo doit fonctionner sur Graph 35+E II ou sur Graph 90+E. Dans les deux cas, vous pouvez prendre une capture avec
Screen Receiver.
Si vous n'y arrivez pas, envoyez-moi le code par message privé et je vous enverrai l'image ou l'animation en retour. Vous pourrez alors poster. Ne partagez pas votre code sur ce sujet !
Si vous n'avez pas de Graph 35+E II ou de Graph 90+E, vous pouvez utiliser
les émulateurs officiels qui disposent d'une version d'essai de 90 jours. Si même ça vous est inaccessible (parce que vous avez déjà utilisé la période d'essai, par exemple), vous pouvez m'envoyer le code d'un programme compatible Graph 35+E II ou Graph 90+E et je le lancerai pour vous.
À la fin du concours, vous devrez partager votre code et on discutera des techniques utilisées, des optimisations, et de la créativité dont vous aurez fait preuve pour abuser des mécanismes de tracé pas prévus pour ça.
Les meilleures participations seront classifiées par un petit jury (jusqu'à 5 membres hors participants) pour élire les démos les plus impressionnantes.
Il y a un lot à gagner, l'auteur·e de la meilleure démo graphique recevra une
clé USB multi-émulateurs à usage à vie. Cette clé USB contient les trois émulateurs
fx-92 Spéciale Collège+,
Graph 35+E II et
Graph 90+E, tous utilisables dans leur version complète sans limite de durée pourvu que la clé USB soit branchée à l'ordinateur. Ce système permet d'utiliser les émulateurs sur plusieurs ordinateurs sans difficulté !
Les deux émulateurs de Graph sont dans les premières versions Python. Mais pas d'inquiétude, car cette clé USB peut être mise à jour avec les nouvelles versions de l'OS ! Comme annoncé durant
la tournée pédagogique en ligne ce mois-ci, la mise à jour avec les bibliothèques graphiques est disponible pour les clés USB d'émulation. Casio a pensé à tout !
Alors évidemment, contrairement au CPC ce petit concours repose sur un système de notation assez subjectif. J'espère que tout le monde saura prendre le lot comme une incitation à participer, avec le recul suffisant pour éviter les mauvaises surprises à la fin !
À vos calculatrices !
Je compte sur vous pour envoyer le feu avec ces nouveaux modules. Si les participations sont vraiment stylées, on pourra en mettre en page d'accueil !
Je déclare le concours de démos graphiques Python ouvert !
Fichier joint
Citer : Posté le 27/04/2020 13:19 | #
Malheureusement non, c'est pas possible.
Citer : Posté le 27/04/2020 13:20 | #
Ah merde...
Citer : Posté le 27/04/2020 17:51 | # |
Fichier joint
Voiçi ma participation à la démo en attendant Bad Apple
Citer : Posté le 27/04/2020 17:54 | #
Propre :o
Citer : Posté le 27/04/2020 17:56 | #
BTW, merci Senpai pour la capture ♥
Ajouté le 27/04/2020 à 18:12 :
Ho, et tant que j'y pense de mon point de vue pour que tout le monde soit noté de manière égale, si on autorise l'overclock c'est forcer tout le monde à l'utiliser pour rester compétitif, mais il y a plein de raison pour lesquelles une personne ne pourrait ou ne voudrait pas overclock( e.g. peur de bricker sa machine, emulateur, etc...)
Ainsi je suis contre malgré le fait que je pourrais en avoir besoins
Citer : Posté le 27/04/2020 21:29 | # |
Fichier joint
En attendant mieux, vlà un classique. C'est codé à l'arrache en 2 heures, donc y'a sûrement moyen d'optimiser, mais la flemme
Vous pouvez ajuster quelques paramètres :
_fall : la vitesse de chute
_group : l'espacement entre deux caractères
_flux : le nombre de "flux" qui tombent
_colors : le nombre de couleurs dans le dégradé (et du coup le nombre de caractères par "flux")
Attention, la complexité est en O(_flux×_colors) : plus y'a d'entités, plus c'est lent…
Enjoy!
Je suis pas contre une capture vidéo si quelqu'un a le screenreceiver
from casioplot import clear_screen, show_screen, set_pixel, draw_string
from itertools import enumerate
from random import randint
_fall = 12
_group = 11
_flux = 5
_colors = 6
X, Y = 384, 192
sprites = [
[0x54,0x10,0xfe,0x82,0xba,0xaa,0xba],
[0xee,0xaa,0xee,0x92,0x92,0xaa,0xc6],
[0xfc,0x84,0x84,0xfc,0x80,0x82,0x7e],
[0xfe,0x10,0x34,0xd2,0x10,0x10,0xfe],
[0xfc,0x4,0x4,0xfc,0x80,0x82,0x7e],
[0xfe,0x0,0x7c,0x44,0x7c,0x40,0x80],
[0x8,0xfe,0x8,0xc,0x18,0xe8,0x18],
[0x28,0x5e,0xd2,0x5e,0x52,0x52,0x5e],
[0x20,0x2e,0xf2,0x24,0x10,0x10,0x10],
[0x44,0x44,0x44,0x44,0x4,0x8,0x30],
[0xee,0xaa,0xee,0x82,0x82,0x82,0x86],
[0x7c,0x14,0xfe,0x14,0x7c,0x20,0xc0],
[0x48,0x48,0xfe,0x48,0xc8,0x48,0x5c],
[0x10,0xfe,0x54,0x38,0x54,0x28,0xc6],
[0x20,0x3e,0x42,0xa2,0x12,0x2,0x6],
[0xe4,0xa4,0xea,0xbe,0xe0,0xae,0xae]
]
colors = [(0, i, 0) for i in range(0, 257, 256//_colors)]
def init():
"""Create a black screen"""
for x in range(X):
for y in range(Y):
set_pixel(x, y, colors[0])
def sprite(px, py, sprite, color):
# Sprites are coded on 8 bytes
c = [(0, 0, 0), color]
for y in range(7):
for x in range(8):
set_pixel(px+x, py+y, c[bool(sprite[y]&(1<<x))])
def up_flux(f):
# flux = [x, y, [particles]]
(x, y, parts) = f
for i in range(len(parts)):
# Erase previous
sprite(x, y + i * _group, sprites[parts[i]], colors[0])
# Create new random
parts[i] = randint(0, 15)
# Update the position
y += _fall
# Outside of screen
if y > Y:
f[0] = randint(0, X)
y = randint(-2*_colors, -_colors)*_group
f[1] = y
# Draw new ones
for i in range(len(parts)):
sprite(x, y + i * _group, sprites[parts[i]], colors[i])
init()
flux = [[randint(0, X), randint(0, Y)*_group, [0 for i in range(_colors)]] for j in range(_flux)]
while True:
for f in flux:
up_flux(f)
show_screen()
def enumerate(l):
i = 0
for e in l:
yield i, e
i += 1
Citer : Posté le 28/04/2020 12:21 | #
Voilà une capture avec les paramètres par défaut et à vitesse réelle.
Edit : Sauf si Firefox, comme chez moi, ralentit systématiquement les GIFs... allez savoir.
Aussi, deux points supplémentaires :
• Vu les avis exprimés (2 contre et 2 neutres), l'overclock ne sera pas utilisé pour la notation des animations.
• Screen Receiver détruit la performance et n'as pas la capture vidéo qu'il y avait dans mes souvenirs, donc n'hésitez pas à m'envoyer votre code pour que je fasse les captures si vous n'arrivez pas à obtenir quelque chose de satisfaisant. Je les lances dans pygame en ajustant la vitesse selon ce que je vois à l'écran de la calto.
Citer : Posté le 28/04/2020 12:25 | #
OK pour l'overclock, est-ce que tu pourrais partager ton "port" Pygame ?
Citer : Posté le 28/04/2020 12:27 | #
Yup ! Voici pour Graph 90+E, pour la Graph 35+E II il suffit de changer la taille de l'écran à 128x64 :
import pygame
pygame.init()
screen = pygame.display.set_mode((384, 192))
def set_pixel(x, y, color):
pygame.draw.rect(screen, color, pygame.Rect(x, y, 1, 1))
def clear_screen():
screen.fill((255,255,255))
def show_screen():
pygame.display.flip()
Il faut Ctrl-C pour arrêter le programme évidemment.
Citer : Posté le 28/04/2020 12:28 | #
Superbe, merci pour les captures !
Citer : Posté le 28/04/2020 12:31 | #
Merci
Il me semble que clear_screen raffraichit l'écran (sur 90+e tout du moins).
Ajouté le 28/04/2020 à 15:16 :
J'ai amélioré un peu le script de Lephé', il devrait maintenant supporter toutes les fonctions de bases de la calto.
import pygame
pygame.init()
SCREEN_WIDTH = 384
SCREEN_HEIGHT = 192
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
draw_string = print
def set_pixel(x, y, color):
pygame.draw.rect(screen, color, pygame.Rect(x, y, 1, 1))
def get_pixel(x, y):
if x >= SCREEN_WIDTH or y >= SCREEN_HEIGHT or x < 0 or y < 0:
return None
return screen.get_at((x, y))[:2]
def clear_screen():
screen.fill((255,255,255))
show_screen()
def show_screen():
pygame.display.flip()
Citer : Posté le 28/04/2020 15:23 | #
Merci ! Il reste que le texte mais je doute qu'on s'amuse à recopier la police. xD
Citer : Posté le 29/04/2020 09:44 | #
C'est à peu près ça, en effet. Pas fou, mais comme je l'ai dit c'est codé à l'arrache x)
Citer : Posté le 29/04/2020 10:07 | #
Heu, il me semble aue clear_screen n'appelle pas show_screen (?)
Citer : Posté le 29/04/2020 10:09 | #
Si, c'est le cas ; je viens de vérifier sur les deux. C'est stupide, mais c'est le cas. ^^"
Citer : Posté le 29/04/2020 10:23 | #
Heu, pas chez moi…
def f(*c):
clear_screen()
for x in range(100):
for y in range(100):
set_pixel(x, y, c)
show_screen()
for i in range(0, 255, 5):
f(i, i, i)
Et j'ai bien les couleurs qui s'affichent au fur et à mesure, sans passage au blanc
Citer : Posté le 29/04/2020 11:30 | #
Plus simple, plus simple.
clear_screen()
set_pixel(10,10,(0,0,0))
show_screen()
clear_screen()
Résultat : écran blanc.
Citer : Posté le 29/04/2020 11:56 | #
clear_screen()
set_pixel(10,10,(0,0,0))
show_screen()
clear_screen()
while True:
pass
Résultat : un pixel noir à l'écran.
show_screen n'est pas appelé à la fin de clear_screen, mais à la fin de l'exécution d'un programme.
Citer : Posté le 29/04/2020 12:09 | #
Fair enough, j'achète.
Citer : Posté le 29/04/2020 12:15 | #
Ce qui serait bon de documenter quelque part d'ailleurs >_>
On a pas encore de page dédiée à casioplot sur le Wiki ? Ou on met ça ailleurs ? Y'a le wiki, la liste des fonctions Basic (faire une nouvelle catégorie Python), le forum, à voir.
Je suis chaud pour commencer à créer des pages spéciales Python sur le Wiki.
Citer : Posté le 29/04/2020 12:16 | #
On n'a rien de tel à ma connaissance. Je pense que le wiki est un bon plan, n'hésite pas à lancer ce que tu as !