Discussion :

[Quartman]

Bonjour à tous, et merci d'avance à ceux qui s'attarderons sur mon problème.

Je vais tenter d'être clair et concis...

Lors de ma licence je suis un cours intitulé Informatique graphique. Durant ce cours nous utilisons python 2.7 et le module Pygame. Le prof nous à fournis un fichier source que nous complétons au fur et à mesure des TP's. Dernièrement nous devions compléter une fonction de "découpage" de segment. Si les points d'un segment dépasse de la fenêtre image (délimitée par un rectangle rouge lors de l'affichage) alors la fonction coupe le segment afin que celui ci ne sorte plus de la fenêtre.
Là où ça fait mal : c'est que l'une de mes conditions (qui doit vérifier si touts les points ne sont pas déjà dans la fenêtre est donc sortir de la boucle de découpage) est respectée alors qu'elle ne le devrait pas...

La condition coupable se situe ligne 41.
Ce sont les variables définissant les positions relatives des points (gauche, droite, ect) qui donne l'état de la condition.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
################################################################################
# Découpage d'un segment réel
################################################################################
def DecoupeSegmentReel(pr1, pr2, fr):
    npr1 = PointReel(pr1.x, pr1.y)
    npr2 = PointReel(pr2.x, pr2.y)
 
#Positions relatives pr1
 
    gauche1 = npr1.x < fr.bg.x    
    droite1 = npr1.x > fr.hd.x
    bas1 = npr1.y < fr.bg.y
    haut1 = npr1.y > fr.hd.y
 
 
 
#positions relatives pr2
 
    gauche2 = npr2.x < fr.bg.x
    droite2 = npr2.x > fr.hd.x   
    bas2 = npr2.y < fr.bg.y
    haut2 = npr2.y > fr.hd.y
 
 
    tdedans = False  #Devient True si toutes les positions sont à l'intérieur de cadre
    tdehors = False   #Devient True si les segments sont entièrement hors du cadre
 
    dx = npr2.x - npr1.x
    dy = npr2.y - npr1.x 
 
    while tdedans == False & tdehors == False :
        #Si tout est en dehors de la fenêtre (le segment et ses points, donc on ne trace rien)
 
        if ((gauche1 & gauche2) or (droite1 & droite2) or (bas1 & bas2) or (haut1 & haut2)) :
            npr1.x = fr.bg.x - 1
            npr1.y = fr.bg.y - 1
            tdehors = True
            print "tdehors = ", tdehors, "\n"
 
        #Si tout les points sont à l'intérieur de la fenêtre (donc on ne découpe pas/plus et on trace)   ET C'EST LA QUE CA MERDE
        if (gauche1 == False & droite1 == False & bas1 == False & haut1 == False) & (gauche2 == False & haut2 == False & droite2 == False & bas2 == False) :
            tdedans = True
 
        elif gauche1 :
            npr1.y = (fr.bg.x - npr1.x)*((dy/dx) - npr1.y)
            npr1.x = (fr.bg.x)
            gauche1 = False
 
        elif droite1 :
            npr1.y = (fr.hd.x - npr1.x)*((dy/dx) - npr1.y)
            npr1.x = fr.hd.x
            droite1 = False
 
        elif haut1 :
            npr1.y = fr.hd.y 
            npr1.x = (fr.hd.y - pr1.y)*((dy/dx) - npr1.x)
            haut1 = False
 
        elif bas1 :
            npr1.y = fr.bg.y
            npr1.x = (fr.bg.y - npr1.y)*((dy/dx) - npr1.x)
            bas1 = False
 
        elif gauche2 :
            npr2.y = (fr.bg.x - npr2.x)*((dy/dx) - npr2.y)
            npr2.x = (fr.bg.x)
            gauche2 = False
 
        elif droite2 :
            npr2.y = (fr.hd.x - npr2.x)*((dy/dx) - npr2.y)
            npr2.x = fr.hd.x
            droite2 = False
 
        elif haut2 :
            npr2.y = fr.hd.y
            npr2.x = (fr.hd.y - npr2.y)*((dy/dx) - npr2.x)
            haut2 = False
 
        elif bas2 :
            npr2.y = fr.bg.y
            npr2.x = (fr.bg.y - npr2.y)*((dy/dx) - npr2.x)
            bas2 = False
 
    return (npr1, npr2)

Je vous affiche aussi le fichier dans lequel j'avais fais afficher les variables durant l'exécution :
(Notons que la boucle se répète trois fois, puisqu'il s'agit d'afficher un triangle).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
gauche1 =  False
droite1 =  False
bas1 =  False
haut1 =  False
gauche2 =  False
droite2 =  True
bas2 =  False
haut2 =  False
 
tdedans avant boucle =  False
tdehors avant boucle =  False 
 
tdedans =  True 
 
gauche1 =  False
droite1 =  True
bas1 =  False
haut1 =  False
gauche2 =  False
droite2 =  False
bas2 =  False
haut2 =  True
 
tdedans avant boucle =  False
tdehors avant boucle =  False 
 
tdedans =  True 
 
gauche1 =  False
droite1 =  False
bas1 =  False
haut1 =  False
gauche2 =  False
droite2 =  False
bas2 =  False
haut2 =  True
 
tdedans avant boucle =  False
tdehors avant boucle =  False 
 
tdedans =  True 
 
Programme terminé.

Ma question est donc : Pourquoi la condition est respectée alors que l'on voit clairement dans le fichier de débuggage que toutes les variables ne sont pas sur False ?!

Je vous demanderez de ne pas vous souciez de ce qui se situe après la condition. Je sais parfaitement que c'est incorrecte, mais pour cette partie je n'ai pas encore épuisé mes ressources

Je pense que d'autres précisions seraient nécessaires, mais j'ai peur d'alourdir le problème. Donc je préfère attendre de répondre à vos éventuelle question.

Pour ceux que ça intéresse (éventuellement) je met le fichier entier à disposition. Il aurait été trop lourd à afficher entièrement.
infographie.py


Encore une fois d'avance !

[Invité]

Bonjour,

vous utilisez des ET binaires (&) au lieu d'utiliser des ET logiques (and).

Copiez/collez le test suivant dans un script test.py et essayez-le :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
print "ET binaire :", 1 & 2     # ET binaire
print "ET logique :", 1 and 2   # ET logique
 
# test
 
gauche1 = droite1 = haut1 = bas1 = False
gauche2 = haut2 = bas2 = False
droite2 = True
 
# votre test utilise des ET binaires (&) /!\
print (
    (gauche1 == False & droite1 == False & haut1 == False & bas1 == False)
    & (gauche2 == False & droite2 == False & haut2 == False & bas2 == False)
)
# première correction : mettre des parenthèses pour préciser les expressions :
print (
    ((gauche1 == False) & (droite1 == False) & (haut1 == False) & (bas1 == False))
    & ((gauche2 == False) & (droite2 == False) & (haut2 == False) & (bas2 == False))
)
# MAIS, en réalité :
# un tel test devrait plutôt utiliser des ET logiques (and) /!\
print (
    (gauche1 == False and droite1 == False and haut1 == False and bas1 == False)
    and (gauche2 == False and droite2 == False and haut2 == False and bas2 == False)
)
# POUR FINIR :
# simplification de votre test
print not any([gauche1, droite1, haut1, bas1, gauche2, droite2, haut2, bas2])

@+.

[Quartman]

Merci pour votre réponse, ça marche bien mieux (si ce n'est que je dois encore corriger mes formules et les compléter).

vous utilisez des ET binaires (&) au lieu d'utiliser des ET logiques (and).

Je ne savais pas qu'il y avait une différence, en tout cas les profs ne nous ont rien dits à ce sujet

[Invité]

Merci pour votre réponse, ça marche bien mieux (si ce n'est que je dois encore corriger mes formules et les compléter).
Je ne savais pas qu'il y avait une différence, en tout cas les profs ne nous ont rien dits à ce sujet

L'informatique, c'est souvent apprendre à chercher l'information par soi-même.

D'ailleurs, puisqu'on en parle, jetez un oeil dans la doc officielle :

https://docs.python.org/3/library/st...ons-and-or-not

Lisez les points 4.1 jusqu'à 4.4.1, vous verrez qu'ils y disent des choses particulièrement intéressantes.

Bon courage.

@+.

[Quartman]

Je cherche de mon côté bien sur. Mais je n'imaginais pas qu'il y avait une quelconque différence entre & et and...

En tout cas, merci encore. Je vais lire la doc (et améliorer mon anglais du même coup ).