Bonjour.

J'expérimente l'utilisation du module turtle. Pour cela j'ai rédigé un code qui génère une matrice contenant un plan (un carre tout simple). Grace au module turtle les bords du carré seront tracés en blanc sur un fond noir en tenant compte de la matrice. Ensuite ce carré sera rempli de haut en bas en jaune.

Tout se passe bien mais je remarque que la vitesse d'exécution varie, surtout dans la deuxième moitié du remplissage. Comment y remédier car je voudrais que cela se fasse de façon linéaire.

Merci

# IMPORTATION DES BIBLIOTHEQUES
import turtle

# CONSTANTES
TAILLE_FENETRE = (600, 600)
ZONE_PLAN_MINI = (-TAILLE_FENETRE[0]/2, -TAILLE_FENETRE[1]/2)  # Coin inférieur gauche de la zone d'affichage du plan
ZONE_PLAN_MAXI = (TAILLE_FENETRE[0]/2, TAILLE_FENETRE[1]/2)  # Coin supérieur droit de la zone d'affichage du plan
TAILLE_CASE =6

# Les valeurs ci-dessous définissent les couleurs des cases du plan
COULEUR_CADRE = 'white'
COULEUR_REMPLISSAGE = 'yellow'

COULEURS = [COULEUR_CADRE, COULEUR_REMPLISSAGE]

def generer_matrice(larg, long):
    """
        Fonction de generation du texte contenant le plan en matrice
        Entree: Largeur et longueur du plan
        Sortie: Matrice representant le plan
    """
    mat_plan = []
    for i in range(larg):
        largList = []
        for j in range(long):
            if i == 0 or i == larg-1 or j ==0 or j == long-1:
                largList.append(1)
            else:
                largList.append(0)
        mat_plan.append(largList)
    return mat_plan

def coordonnees(case, TAILLE_CASE):
    """
        Fonction de calcul des coordonnees du point de depart pour le dessin d'une case
        Entree: numero de ligne et de colonne de la case dans la matrice;longueur d'un cote
        Sortie: Coordonnee de depart du dessin d'un carre
    """
    coord_case_init = (ZONE_PLAN_MINI[1], ZONE_PLAN_MAXI[1])
    x = coord_case_init[0] + case[1] * TAILLE_CASE
    y = coord_case_init[1] - case[0] * TAILLE_CASE
    return (x, y)

def tracer_carre(dimension):
    """
        Fonction pour dessiner une case
        Entree: longueur d'un cote
        Sortie: Dessin d'un carre
    """
    for _ in range(4):
        turtle.forward(dimension)
        turtle.right(90)

def tracer_case(case, couleur, TAILLE_CASE):
    """
        Fonction pour aller aux coordonnees d'une case et la dessiner
        Entree: coordonnees de la case a dessiner, sa couleur et sa largueur
        Sortie: appel de la fonction Dessin d'un carre
    """
    turtle.goto(case)
    turtle.down()
    turtle.color(couleur, couleur)
    turtle.begin_fill()
    tracer_carre(TAILLE_CASE)
    turtle.end_fill()
    turtle.up()

def afficher_plan(matrice):
    """
        Fonction pour afficher le plan du jeu
        Entree: matrice representant le plan
        Sortie: appels des fonctions de Dessin de carre
    """
    turtle.tracer(1000)
    for i in range(len(matrice)):
        for j in range(len(matrice[i])):
            case = coordonnees((i, j), TAILLE_CASE)
            if matrice[i][j] == 1:
                tracer_case(case, COULEURS[0], TAILLE_CASE)

def arret():
    turtle.done()


def parcourir_plan(matrice):
    turtle.tracer(10)
    for i in range(len(matrice)):
        for j in range(len(matrice[i])):
            if i != 0 and i != (len(matrice) - 1) and j != 0 and j != (len(matrice[i]) - 1):
                case = coordonnees((i, j), TAILLE_CASE)
                tracer_case(case, COULEURS[1], TAILLE_CASE)
                turtle.listen()
                turtle.onkey(arret, "")



turtle.hideturtle()
turtle.screensize(canvwidth=TAILLE_FENETRE[0], canvheight=TAILLE_FENETRE[1], bg='black')
matrice = generer_matrice(int(TAILLE_FENETRE[0]/TAILLE_CASE), int(TAILLE_FENETRE[1]/TAILLE_CASE))
afficher_plan(matrice)
parcourir_plan(matrice)
turtle.listen()
turtle.done()

beam1916 a écrit:

Tout se passe bien mais je remarque que la vitesse d'exécution varie, surtout dans la deuxième moitié du remplissage. Comment y remédier car je voudrais que cela se fasse de façon linéaire.

Au plus on ajoute d'objets dans le Canvas (associé à le turtle) au plus ça va ramer... A vous de trouver une solution pour avoir un rendu identique (on voit la même chose) avec moins d'objets à créer...

Merci mps.

J'ai créé l'objet remplir au debut, qui va me servir dans toutes les fonctions:

remplir = turtle.Turtle()

Cela marche toujours mais rame quand meme. 

ça ne changera pas le nombre d'éléments à afficher. ce qui pourrait être fait c'est qu'au lieu de tracer des carrés , tu donnes l'épaisseur voulu à la tortue et tu traces juste des traits (et éventuellement modifier la vitesse de la tortue)

umfred a écrit:

ça ne changera pas le nombre d'éléments à afficher. ce qui pourrait être fait c'est qu'au lieu de tracer des carrés , tu donnes l'épaisseur voulu à la tortue et tu traces juste des traits (et éventuellement modifier la vitesse de la tortue)

Vu que ça dessine un grand carré jaune à partir de plein de petits carrés, dessiner un (seul) grand carré irait plus vite.

Mais tout dépend de ce qu'on va chercher à faire après... (en supposant que ce code est sous ensemble de...).

Ça vaudrait peut-être la peine de trouver les carrés adjacents et de dessiner un plus grand rectangle avec un trait suffisamment large.
Ce calcul ne peut pas être plus long que le traçage lui-même.

Merci vous tous pour vos interventions. En effet, afficher beaucoup d'objets faisait ramer la machine. La solution que j'ai adoptée a consisté a définir une dimension d'affichage que jai ensuite utilisée pour tracer une ligne a la fois (horizontalement), jusqua obtenir le remplissage complet du carreau. Une sorte de barre(carreau) de chargement.

# IMPORTATION DES BIBLIOTHEQUES
import turtle

# CONSTANTES
TAILLE_FENETRE = (600, 600)
ZONE_PLAN_MINI = (-TAILLE_FENETRE[0]/2, -TAILLE_FENETRE[1]/2)  # Coin inférieur gauche de la zone d'affichage du plan
ZONE_PLAN_MAXI = (TAILLE_FENETRE[0]/2, TAILLE_FENETRE[1]/2)  # Coin supérieur droit de la zone d'affichage du plan

# Les valeurs ci-dessous définissent les couleurs des cases du plan
COULEUR_CADRE = 'white'
COULEUR_REMPLISSAGE = 'yellow'

COULEURS = [COULEUR_CADRE, COULEUR_REMPLISSAGE]

remplir = turtle.Turtle()


remplir.hideturtle()
turtle.screensize(canvwidth=TAILLE_FENETRE[0], canvheight=TAILLE_FENETRE[1], bg='black')
remplir.width(5)
remplir.color('white')
remplir.penup()
remplir.goto(-300,300)
remplir.pendown()
for i in range(4):
    remplir.forward(600)
    remplir.right(90)
    i=+1
for j in range(295,-300,-5):
    remplir.speed(0)
    remplir.penup()
    turtle.tracer(n=2, delay=100)
    remplir.goto(-300 + 5, j)
    #remplir.goto(-300+5,300-5)
    remplir.pendown()
    #turtle.tracer(3)
    remplir.color('yellow')
    remplir.forward(600-10)
    print(j)
turtle.done()