On désire mettre en place un outil de géométrie analytique qui nous permettrait de calculer des points d'intersections, des centres de gravités, des longueurs, des aires…

C'est un bon exemple d'utilisation des classes et peut-être vu comme un prolongement de cet exercice.

Pour faire simple, on se contente de résultats approximatifs, sous forme de float.

C'est un type primitif qui ne doit dépendre d'aucun autre.

Le point est défini par ses coordonnées. À ce titre, on s'autorisera à faire des sommes et des différences de points comme avec des vecteurs puisque. En effet, dans le cadre de notre application, un point n'est rien d'autre qu'une paire de coordonnées.

Quelques précisions sur les méthodes :

• A.distance(B) permettra d'obtenir la distance entre les points A et B
• A.milieu(B) permettra d'obtenir le point milieu du segment [AB]
• La méthode magique __add__ permet d'obtenir le point somme A + B (définit l'opérateur + entre deux objets de type Point)
• La méthode magique __sub__ permet d'obtenir le point différence A - B (définit l'opérateur - entre deux objets de type Point)
• La méthode magique __mul__ permet d'obtenir le point produit A * k où k est un nombre. Vous comprenez qu'on parle en termes de coordonnées.
• La méthode magique __truediv__ permet d'obtenir la division A / k où k est un nombre. Là encore il s'agi de coordonnées.
• La méthode magique __str__ indique à Python quoi faire quand on demande un transtypage str(A). On souhaite que cette fonction renvoie les coordonnées du point sous la forme $(x\,;\,y)$.
• La méthode magique __repr__ est utilisée lors de l'affichage d'un point en console.

L'objet Droite décrit une droite. Cette classe est dépendante de la classe Point.

Une droite est définie par une équation. La forme la plus générale d'équation est $a\cdot x + b\cdot y + c = 0$. C'est l'équation cartésienne. On utilisera cette forme et pas $y = m\cdot x + p$ qui n'est pas valable pour une droite verticale.

Quelques précisions sur les méthodes :
dans ce qui suit d1 et d2 sont des droites, A un point.

• d1.is_parallel(d2) renvoie True si les deux droites sont parallèles.
  deux droites sont parallèles si $a\cdot b' = a' \cdot b$
• d1.perp_by_point(A) renvoie la droite perpendiculaire à d1 et passant par A.
  Une perpendiculaire a les coefficients $a' = -b$ et $b' = a$
• d1.inter(d2) renvoie le point intersection des deux droites.
  précondition : les deux droites ne sont pas parallèles
  $x = -\frac{c\cdot b' - c'\cdot b}{a\cdot b' - a'\cdot b}$ et $y = -\frac{c\cdot a' - c'\cdot a}{b\cdot a' - b'\cdot a}$
• d1.has_point(A) renvoie True si le point est sur la droite.
  Tester si $a\cdot x_A + b\cdot y_A + c = 0$
• d1.is_perp(d2) renvoie True si les deux droites sont perpendiculaires
  si $a\cdot a' + b \cdot b' = 0$
• Les méthodes magiques __str__ et __repr__ répondent au même besoin que pour Point. On souhaite que ces fonctions renvoient l'équation de la droite au format str.

On aimerait disposer d'autres fonctions :

• une fonction par_deux_pts(A:Point, B:Point) → Droite renvoyant droite passant par deux points,
  Les coefficients pour la droite $(AB)$ sont $a = y_B - y_A$, $b = -(x_B - x_A)$ et $c = -a\cdot x_A - b \cdot y_A$
• une fonction mediatrice(A:Point, B:Point) → Droite renvoyant la médiatrice su segment [AB]
  C'est la perpendiculaire à (AB) passant par le milieu de [AB]

• si on les place dans Point, l'objet Point devient dépendant de Droite ce qu'on préférait éviter,
• on ne peut les placer dans la classe Droite car les méthodes de Droite concernent toujours une droite qui existe déjà. Mais ces deux fonctions servent à créer une droite (qui n'existe donc pas encore) à partir d'autre chose qu'une droite… D'ailleurs, vous voyez qu'il n'y a pas self dans la définition de ces fonctions.
• on peut créer une classe Segment. Un objet de cette classe serait défini par deux points. La fonction mediatrice serait une méthode d'un objet Segment. Cette approche est rigoureuse et logique : en mathématique, la médiatrice appartient à un segment, pas à un point ou une droite. Il est donc naturel de donner à Segment la responsabilité de la médiatrice. Le seul défaut de cette approche est d'obliger à créer une classe en plus.
• on peut les placer dans le module droite.py comme fonctions ordinaires, à côté de la classe Droite. C'est une bonne option. Son seul tort est de ne pas tout empaqueter dans la classe, ce qu'on préfère quand on commence à faire des classes.
• plus technique, on peut placer ces fonctions dans la classe Droite mais en signalant qu'elles fonctionnent autrement. On pourra écrire :

class Droite:
    # ...
    @staticmethod
    def par_deux_pts(A:Point, B:Point) -> 'Droite':
        '''
        renvoie la droite (AB)
        '''
        a = B.y - A.y
        b = -(B.x - A.x)
        c = -a*A.x - b*A.y
        return Droite(a, b, c)
        
# usage avec deux points A et B :
d = Droite.par_deux_points(A, B)

Un objet Triangle décrit un triangle. Il est défini par ses trois sommets. Cette classe est dépendante des classes Point et Droite.

Quelques précisions sur les méthodes :
Ci-dessous, t est de type Triangle

• t.aire() renvoie l'aire du triangle
• t.perimeter() renvoie le périmètre du triangle
• t.G() renvoie le centre de gravité
• t.O() renvoie le centre du cercle circonscrit (intersection des médiatrices)
• t.H() renvoie l'orthocentre (intersection des hauteurs)
• t.is_rectangular() renvoie True si le triangle est rectangle
• __str__ et __repr__ renvoient une représentation texte du triangle. On pourra par exemple renvoyer la liste des coordonnées des 3 sommets.

• On peut continuer ce jeu en ajoutant encore et encore des fonctions et des objets.
• on peut aussi ajouter une interface graphique donnant une représentation des objets créés. On pourrait par exemple utiliser matplotlib ou encore tkInter.