Dessiner un cyclone en Python avec un nombre de cycles donné?

Question

Je n'arrive pas à dessiner un cyclone avec un nombre de cycles entrés. Le code est censé faire en sorte que l'utilisateur clique sur un point de départ et un point de fin, puis un cyclone sera tracé avec des cycles entrés du point de départ au point de fin.

from math import * 
from graphics import * 

def main(): 
    win = GraphWin("Drawing a Cyclone",600,450)    
    win.setCoords(0,0,600,450)        
    msg = "Please enter the number of cycles, and click the start and end positions in the window." 
    Text(Point(300, 438), msg).draw(win) 
    Text(Point(65,415),"# of cycles:").draw(win) 
    inbox =Entry(Point(130,415),5) 
    inbox.draw(win) 


    start=win.getMouse() 
    start.setFill("red") 
    start.draw(win) 
    stop=win.getMouse() 
    stop.setFill("red") 
    stop.draw(win) 

    cycles=eval(inbox.getText()) 
    radius = 0             
    length = sqrt((stop.x-start.x)**2+(stop.y-start.y)**2) 
    step_radius = length/(120*cycles) 
    radian = atan((stop.y-start.y)/(stop.x-start.x)) 
    initial_angle = int(degrees(radian)) 

    for i in (0, cycles*360, 3): 
     radius = radius + step_radius 
     theta=radians(initial_angle + (360*cycles*i)+3*i) 
     stop.x = start.x + radius*cos(theta) 
     stop.y = start.y + radius*sin(theta) 
     line=Line(start,stop) 
     line.draw(win) 
     start.x=stop.x 
     start.y=stop.y 


    win.getMouse() 
    win.close() 

main() 

This is what I'm getting

This is what I'm supposed to get

Answer 1

Je dirais que la plus grande partie de votre centre de problèmes autour de ce code:

theta=radians(initial_angle + (360*cycles*i)+3*i) 
stop.x = start.x + radius*cos(theta) 
stop.y = start.y + radius*sin(theta) 

La variable i est en train de tracer déjà les cercles si theta devraient être radians équivalent de i avec un ajustement pour l'angle initial, mais vous avez fait beaucoup de maths supplémentaires avec i. En outre, la position d'arrêt doit être une fonction des calculs cos() et sin() corrigés pour l'origine de la figure, mais vous utilisez start qui était à l'origine l'origine mais qui est une cible mobile à l'intérieur de la boucle.

Une façon d'effectuer le débogage consiste à définir les cycles sur 1 et à définir radius = length au lieu de radius += step_radius. Cela vous donnera un cercle simple pour résoudre les problèmes de positionnement, rayon, etc. sans la complication supplémentaire de la spirale. Puis rajoutez la spirale.

Quelque chose de plus dans ce sens pourrait vous donner quelques idées ce qu'il faut corriger:

from math import * 
from graphics import * 

DEGREES_PER_STEP = 3 

win = GraphWin("Drawing a Cyclone", 600, 450) 
win.setCoords(0, 0, 600, 450) 
msg = "Please enter the number of cycles, and click the start and end positions in the window." 
Text(Point(300, 438), msg).draw(win) 
Text(Point(65, 415), "# of cycles:").draw(win) 
inbox = Entry(Point(130, 415), 5) 
inbox.draw(win) 

origin = win.getMouse() 
origin.setFill("green") 
origin.draw(win) 
target = win.getMouse() 
target.setFill("red") 
target.draw(win) 

cycles = float(inbox.getText()) 
radius = 0 
length = sqrt((target.x - origin.x) ** 2 + (target.y - origin.y) ** 2) 
step_radius = length/(cycles * 360/DEGREES_PER_STEP) 
initial_angle = atan((target.y - origin.y)/(target.x - origin.x)) 

start = Point(origin.x, origin.y) 

for i in range(0, int(cycles * 360), DEGREES_PER_STEP): 
    radius += step_radius 
    theta = radians(i) + initial_angle # initial angle already in radians 
    stop = Point(origin.x + radius * cos(theta), origin.y + radius * sin(theta)) 
    line = Line(start, stop) 
    line.draw(win) 
    start = stop 

win.getMouse() 
win.close() 

Cela a encore des problèmes à obtenir l'angle initial correct dans certains quarts de cercle, mais c'est quelque chose que vous pouvez travailler. En outre, si vous cliquez sur les points de juste, vous pouvez générer une division par zéro si vous voulez traiter cela aussi:

Notez que bien que from graphics import * est généralement fait, from math import * est plus risqué - - Par exemple, math.pow() écrase le pow() intégré de Python et les deux ne sont pas identiques. Considérez une importation plus sûre.