Partage
  • Partager sur Facebook
  • Partager sur Twitter

Aide Python

Coordonnées point sur un cercle

Anonyme
    23 décembre 2016 à 1:35:56

    Bonjour,

    Je voulais savoir si quelqu'un pouvait m'aider sur un problème de formules pour trouver un point sur un cercle.

    Voilà, je veux créer un programme capable de représenter un deux cercles :

    le premier étant fixe et le deuxième glissant sur les parois du premier (qui suit la trace du cercle en quelques sortes).

    J'ai fait pas mal de recherches (notamment sur les coordonnées polaires) mais sans succès.

    Est-ce que quelqu'un pourrait m'aider à résoudre ce problème ?

    Merci

    • Partager sur Facebook
    • Partager sur Twitter
      23 décembre 2016 à 9:59:00

      Bonjour,

      Peux-tu expliciter ta question : comment est défini le point dont tu veux trouver les coordonnées ?

      • Partager sur Facebook
      • Partager sur Twitter
      Anonyme
        23 décembre 2016 à 12:09:25

        Bonjour, 

        En fait je veux trouver les coordonnées de plusieurs points .

        Ces points sont en fait le contour du grand cercle .

        Alors le petit cercle devra suivre la trace du grand cercle (il se téléportera de points en points).

        Ces points ont peux les calculer avec les coordonnées cartésiennes (X, y)  ou avec les coordonnées polaires (r, thêta) le problème c'est que je ne sais pas comment faire.

        Je sais juste qu'il faut le rayon et l'angle pour trouver un point sur le cercle mais après je suis perdu dans les formules.

        La seule valeur qui change est l'angle (je crois) car le rayon est le même.

        Merci d'avoir prit connaissance de mon message .

        • Partager sur Facebook
        • Partager sur Twitter
          23 décembre 2016 à 13:20:29

          Donc tu ne cherches pas à déterminer les coordonnées d'un point, mais tu veux exprimer celles d'un ensemble de points, c'est à dire l'équation du cercle.

          Que cherches-tu à faire, précisément ?

          -
          Edité par entwanne 23 décembre 2016 à 13:20:40

          • Partager sur Facebook
          • Partager sur Twitter
          Anonyme
            23 décembre 2016 à 14:30:03

            Exactement, je ne veux pas calculer les coordonnées d'un seul point mais touts les points du cercle, pour ensuite y faire glisser le deuxième cercle.

            Je crois que la méthode consiste à incrémenter l'angle (changer sa valeur) de 0 à 360 degrés pour trouver les points mais je suis toujours coincé au même endroit.

            Voici le code que j'ai commencé à écrire :

            from tkinter import *
            from math import *


            class Area:
                def __init__(self, width, height):
                    """Main class"""

                    self.window_items = {"width": width, "height": height, "size_grid": width / 5, "bg_color": "white"}

                    self.window = Tk()
                    self.window.resizable(0, 0)
                   
                    self.canvas = Canvas(self.window, width=self.window_items["width"], height=self.window_items["height"], bg=self.window_items["bg_color"])
                    self.canvas.pack()
                   
                    self.big_circle = Circle(self.canvas, self.window_items, 100, "white", "blue", None)
                    self.small_circle = Circle(self.canvas, self.window_items, 20, None, "magenta", self.big_circle.items)

                    self.angle = 0

                    self.move_circle(self.small_circle.items, self.big_circle.items)

                    self.window.mainloop()


                def move_circle(self, s_circle, b_circle):
               
            ##        x = self.window_items["width"] / 2 + b_circle["radius"]*cos(self.angle)
            ##        y = self.window_items["height"] / 2 + b_circle["radius"]*sin(self.angle) --> Voila la cause du problème
            ##       
            ##        s_circle["x1"] = x - s_circle["radius"]
            ##        s_circle["x2"] = x + s_circle["radius"]
            ##        s_circle["y1"] = x - s_circle["radius"]
            ##        s_circle["y2"] = x + s_circle["radius"]

                    self.canvas.coords(s_circle["circle"], s_circle["x1"], s_circle["y1"], s_circle["x2"], s_circle["y2"])

                    self.move = self.window.after(1000, lambda: self.move_circle(s_circle, b_circle))

                    self.angle += 1
                   


            class Circle:
                def __init__(self, canvas, win_items, rayon, in_color, out_color, prev_circle):
                    """Create circle"""

                    if prev_circle is None:
                        x1, y1 = win_items["width"] / 2 - rayon, win_items["height"] / 2 - rayon                                                
                        x2, y2 = win_items["width"] / 2 + rayon, win_items["height"] / 2 + rayon
                    else:
                        x1, y1 = win_items["width"] / 2 - rayon, prev_circle["y1"] - rayon                                  
                        x2, y2 = win_items["width"] / 2 + rayon, prev_circle["y1"] + rayon

                    self.items = {"x1": x1,"x2": x2,"y1": y1,"y2": y2,"radius": rayon, "in_color": in_color, "out_color": out_color}
                           
                    circle = canvas.create_oval(x1, y1, x2, y2, fill=in_color, outline=out_color)
                    self.items["circle"] = circle



            if __name__ == "__main__":
                size_win = 400
                obj_area = Area(size_win, size_win)

            • Partager sur Facebook
            • Partager sur Twitter
              23 décembre 2016 à 15:51:06

              La prochaine fois, pense à utiliser des balises code, ça permet entre autres la coloration syntaxique.

              Dans ton code, je ne vois pas de boucle événementielle, mais si je comprends bien, tu cherches à faire tourner un cercle autour d'un autre. À chaque pas de ta boucle, tu auras donc un point différent sur ton cercle « maître ».

              Le plus simple est d'identifier ce point par son angle (que tu incrémenterais, de 1° par exemple, à chaque tour de boucle). Il ne te sera pas nécessaire de connaître les coordonnées de ce point, car ce n'est pas lui que tu manipuleras directement. On peut toute fois le noter M pour s'y retrouver un peu, et α l'angle associé. Par ailleurs, j'ai considéré que le cercle maître était de centre O et de rayon R.

              Fig. 1

              On considère ensuite le cercle esclave, de rayon r (fixé) et de centre A (variable). A est en fait un point du cercle de centre O et de rayon R+r (puisque M appartient aux deux cercles et que O, M et A sont alignés).

              Fig. 2

              A se retrouve associé au même angle α que M, et tu peux donc retrouver ses coordonnées cartésiennes (tu as toutes les données : le centre O, le rayon R+r, et l'angle α, qui forment un repère et des coordonnées polaires). Une fois le point A connu, et connaissant le rayon r du cercle esclave, il ne te reste plus qu'à le tracer.

              Fig. 3

              • Partager sur Facebook
              • Partager sur Twitter
              Anonyme
                23 décembre 2016 à 16:04:50

                Le truc c'est que le cercle "esclave" a pour centre le point M qui est mobile sur le cercle "maitre", est-ce que cela change beaucoup de choses ?

                • Partager sur Facebook
                • Partager sur Twitter
                Anonyme
                  23 décembre 2016 à 16:44:46

                  D'accord, mais mon problème c'est que je n'arrive pas à calculer les coordonnées du point M sur le cercle.

                  • Partager sur Facebook
                  • Partager sur Twitter
                    23 décembre 2016 à 16:55:39

                    Ce n'est pas vraiment un problème de Python alors. Quel est ton niveau en mathématiques ?

                    • Partager sur Facebook
                    • Partager sur Twitter
                    Anonyme
                      23 décembre 2016 à 17:01:25

                      Je suis en 1 ere SSI mais je suis pas hyper fort en maths .

                      Désolé pour le double commentaire, mais est-ce que vous savez comment calculer les coordonnées de M ?

                      Sachant que le centre du cercle "maitre" est le centre de la fenêtre graphique (200, 200) et que le rayon est de 100 pixels et que l'angle change mais j'ai commencé avec un angle de 90 degrés, et sachant que l'axe des ordonnées sur le module tkinter est inversé c-a-d que 0 correspond au haut de la fenêtre.

                      -
                      Edité par Anonyme 23 décembre 2016 à 18:07:45

                      • Partager sur Facebook
                      • Partager sur Twitter
                        23 décembre 2016 à 19:31:17

                        Et dans quel but dois-tu réaliser ce programme, c'est pour un exercice ?

                        Je suppose que tu n'es pas très à l'aise avec les changements de repère, mais tu connais les coordonnées polaires de M dans un repère centré sur O (puisque tu connais le rayon de ton cercle, et que tu connais l'angle α). Tu peux donc opérer une translation pour centrer ton repère sur ce point O.

                        Partant de là, tu peux déterminer facilement les coordonnées cartésiennes de M dans ce repère (par la conversion des données polaires). Il ne reste plus qu'à opérer la translation inverse pour revenir au repère initial.

                        • Partager sur Facebook
                        • Partager sur Twitter
                        Anonyme
                          24 décembre 2016 à 0:45:31

                          Merci beaucoup j'ai réussi, voici le code :

                          from tkinter import *
                          from math import *


                          class Area:
                              def __init__(self, width, height):
                                  """Main class"""

                                  self.window_items = {"width": width, "height": height, "size_grid": width / 5, "bg_color": "white"}

                                  self.window = Tk()
                                  self.window.resizable(0, 0)
                                 
                                  self.canvas = Canvas(self.window, width=self.window_items["width"], height=self.window_items["height"], bg=self.window_items["bg_color"])
                                  self.canvas.pack()

                                  self.commands = Commands(self)
                                  self.angle = 90
                                  self.speed = 1
                                  self.move = None

                                  self.commands.create_entry("Commands : ", (0, 0))

                                  # Create the two circles relative to each other
                                  self.big_circle = Circle(self.canvas, self.window_items, 100, "white", "blue", None)
                                  self.small_circle = Circle(self.canvas, self.window_items, 20, None, "magenta", self.big_circle.items)

                                  self.window.bind("<Return>", lambda event: self.commands.get(event))

                                  self.window.mainloop()


                              def move_circle(self, s_circle, b_circle):
                                  """determine the new coords and move the small circle"""
                                 
                                  rad_angle = self.degrees_to_radians(self.angle)
                                 
                                  x, y = self.calculate_coordinates(rad_angle, b_circle)

                                  self.coords_circle(x, y, s_circle)
                                 
                                  self.canvas.coords(s_circle["circle"], s_circle["x1"], s_circle["y1"], s_circle["x2"], s_circle["y2"])
                                  self.move = self.window.after(30, lambda: self.move_circle(s_circle, b_circle))

                                  self.angle += self.speed


                              def degrees_to_radians(self, deg_angle):
                                  """Convert degrees to radians"""
                                 
                                  rad_angle = radians(deg_angle)

                                  return rad_angle


                              def calculate_coordinates(self, rad_angle, b_circle):
                                  """calculate the small circle's coordinates"""
                                 
                                  x = int(self.window_items["width"] / 2 + b_circle["radius"] * cos(rad_angle))
                                 
                                  inv_y = int(self.window_items["height"] / 2 + b_circle["radius"] * sin(rad_angle))
                                  y = self.window_items["height"] - inv_y

                                  return x, y


                              def coords_circle(self, x, y, s_circle):
                                  """update the small circle's coordinates"""
                                 
                                  s_circle["x1"] = x - s_circle["radius"]
                                  s_circle["x2"] = x + s_circle["radius"]
                                  s_circle["y1"] = y - s_circle["radius"]
                                  s_circle["y2"] = y + s_circle["radius"]       



                          class Commands:
                              def __init__(self, area):
                                  """Use commands to explore functions"""

                                  self.area = area
                                  self.bg = "orange"
                                  self.width = 30
                                  self.commands_dict = {
                                      "speed": self.change_speed,
                                      "moves": self.manage_moves
                                  }


                              def create_entry(self, value, coords):
                                  """create a object on the window"""

                                  value_var = StringVar()
                                  value_var.set(value)
                                 
                                  self.entry = Entry(self.area.window, text=value_var, bg=self.bg, width=self.width)
                                  self.entry.place(x=coords[0], y=coords[1])
                                 

                              def get(self, event):
                                  """get the user input"""

                                  user_input = self.entry.get()

                                  self.inspect_value(user_input)


                              def inspect_value(self, user_input):
                                  """know if it is a good command """

                                  if user_input[0] == "/":
                                      user_input = user_input[1:len(user_input)]

                                      command = ""
                                      index = 0

                                      for car in user_input:
                                          if car != ":":
                                              command = command + car
                                          else:
                                              argument = user_input[index+1:len(user_input)]
                                              break
                                         
                                          index += 1
                                         
                                      try:
                                          self.commands_dict[command](argument)
                                      except:
                                          return


                              def change_speed(self, new_speed):
                                  """change the small circle's speed"""

                                  self.area.speed = int(new_speed)


                              def manage_moves(self, answer):
                                  """launch or stop the small circle"""
                                 
                                  if answer == "1":
                                      self.area.move_circle(self.area.small_circle.items, self.area.big_circle.items)
                                  else:
                                      if self.area.move:
                                          self.area.window.after_cancel(self.area.move)


                              def change_color(self, circle, in_color, out_color):
                                  """change color of a circle"""

                                  # self.area.small_circle.items["circle"]
                                  self.area.canvas.itemconfig(circle["circle"], fill=in_color, outline=out_color)
                             
                                     

                          class Circle:
                              def __init__(self, canvas, win_items, rayon, in_color, out_color, prev_circle):
                                  """Create circle"""

                                  if prev_circle is None:
                                      x1, y1 = win_items["width"] / 2 - rayon, win_items["height"] / 2 - rayon                                                
                                      x2, y2 = win_items["width"] / 2 + rayon, win_items["height"] / 2 + rayon
                                  else:
                                      x1, y1 = win_items["width"] / 2 - rayon, prev_circle["y1"] - rayon                                  
                                      x2, y2 = win_items["width"] / 2 + rayon, prev_circle["y1"] + rayon

                                  self.items = {"x1": x1,"x2": x2,"y1": y1,"y2": y2,"radius": rayon, "in_color": in_color, "out_color": out_color}
                                         
                                  circle = canvas.create_oval(x1, y1, x2, y2, fill=in_color, outline=out_color)
                                  self.items["circle"] = circle



                          if __name__ == "__main__":
                              size_win = 400
                              obj_area = Area(size_win, size_win)

                          • Partager sur Facebook
                          • Partager sur Twitter

                          Aide Python

                          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                          × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                          • Editeur
                          • Markdown