Génération d'illustration simple et aléatoires, grâce à GPT-3

Particule_GPT_1_low-cpu.py

#Aides: GPT-3
# Importe la bibliothèque tkinter pour créer l'interface graphique
import tkinter as tk
import random

# Définit une fonction pour générer une couleur aléatoire
def random_color():
    r = random.randint(0, 255)  # Génère une valeur rouge (0-255)
    g = random.randint(0, 255)  # Génère une valeur verte (0-255)
    b = random.randint(0, 255)  # Génère une valeur bleue (0-255)
    return f'#{r:02X}{g:02X}{b:02X}'  # Retourne la couleur au format hexadécimal

# Définit une fonction pour créer un cercle avec une couleur aléatoire
def create_circle(canvas):
    x = random.randint(50, 350)  # Position x initiale aléatoire
    y = random.randint(50, 350)  # Position y initiale aléatoire
    radius = random.randint(10, 30)  # Rayon aléatoire
    color = random_color()  # Couleur aléatoire
    circle = canvas.create_oval(x, y, x + radius, y + radius, fill=color)  # Crée le cercle sur le canvas
    move_circle(canvas, circle)  # Appelle la fonction pour déplacer le cercle

# Définit une fonction pour déplacer le cercle de manière aléatoire
def move_circle(canvas, circle):
    dx = random.uniform(-1, 1)  # Déplacement horizontal aléatoire
    dy = random.uniform(-1, 1)  # Déplacement vertical aléatoire
    canvas.move(circle, dx, dy)  # Déplace le cercle sur le canvas
    canvas.after(100, move_circle, canvas, circle)  # Appel récursif pour un mouvement continu

# Crée la fenêtre principale de l'application
root = tk.Tk()
root.title("Animation en temps réel avec des cercles de couleurs aléatoires")

# Crée un canvas (zone de dessin) dans la fenêtre
canvas = tk.Canvas(root, width=400, height=400, bg="black")
canvas.pack()

# Crée initialement quelques cercles en utilisant la fonction create_circle
for _ in range(10):
    create_circle(canvas)

# Lance la boucle principale de l'application pour afficher la fenêtre
root.mainloop()

Particule_GPT_2_high-cpu.py

#Aides: GPT-3
import tkinter as tk
import random
# Fonction pour générer une couleur aléatoire
def random_color():
    r = random.randint(0, 255)
    g = random.randint(0, 255)
    b = random.randint(0, 255)
    return f'#{r:02X}{g:02X}{b:02X}'
# Classe pour représenter une particule
class Particle:
    def __init__(self, canvas):
        self.canvas = canvas
        self.radius = random.randint(13, 25)  # Rayon aléatoire de la particule
        self.x = random.randint(self.radius, 113 - self.radius)  # Position x initiale aléatoire
        self.y = random.randint(self.radius, 113 - self.radius)  # Position y initiale aléatoire
        self.color = random_color()  # Couleur aléatoire
        self.dx = random.uniform(-13, 13)  # Déplacement horizontal aléatoire
        self.dy = random.uniform(-13, 13)  # Déplacement vertical aléatoire
    def move(self):
        self.x += self.dx  # Met à jour la position x
        self.y += self.dy  # Met à jour la position y
        if self.x < 0 or self.x > 113:
            self.dx *= -1  # Inverser la direction si la particule atteint les bords horizontaux
        if self.y < 0 or self.y > 113:
            self.dy *= -1  # Inverser la direction si la particule atteint les bords verticaux
    def draw(self):
        self.canvas.create_oval(self.x - self.radius, self.y - self.radius, 
                                 self.x + self.radius, self.y + self.radius,
                                 fill=self.color)  # Dessine la particule sur le canvas
def update_particles(particles):
    for particle in particles:
        particle.move()  # Met à jour la position de chaque particule
        particle.draw()  # Dessine chaque particule avec sa nouvelle position
    root.after(50, update_particles, particles)  # Appel récursif pour une mise à jour continue
root = tk.Tk()
root.title("Effet de particules en mouvement aléatoire")
canvas = tk.Canvas(root, width=113, height=113, bg="pink")
canvas.pack()
num_particles = 1  # Réduire le nombre de particules pour alléger la charge CPU
particles = [Particle(canvas) for _ in range(num_particles)]  # Crée un ensemble de particules
update_particles(particles)  # Démarre la mise à jour des particules
root.mainloop()