Code source de mlstatpy.image.detection_segment.geometrie

# -*- coding: utf-8 -*-
"""
Définition de petits éléments géométriques tels que les points
et les segments, implemente également des opérations standard
telles le produit scalaire entre deux vecteurs, ...


:githublink:`%|py|8`
"""
import math
import copy
import numpy


class Point:
    """
    Définit un point de l'image ou un vecteur,
    deux coordonnées *x* et *y* qui sont réelles.


    :githublink:`%|py|17`
    """
    __slots__ = "x", "y"

    def __init__(self, x, y):
        """
constructeur

:githublink:`%|py|21`
        """
        self.x = x
        self.y = y

    def __str__(self):
        """
permet d'afficher un point avec l'instruction print

:githublink:`%|py|26`
        """
        return '({0},{1})'.format(self.x, self.y)

    def __repr__(self):
        """
usuel

:githublink:`%|py|30`
        """
        return 'Point({0}, {1})'.format(self.x, self.y)

    def normalise(self):
        """
normalise le vecteur, sa norme devient 1

:githublink:`%|py|34`
        """
        v = self.x * self.x + self.y * self.y
        v = math.sqrt(v)
        if v > 0:   # evite les erreurs si sa norme est nulle
            self.x /= v
            self.y /= v

    def scalairek(self, k: float):
        """
        Mulitplication par un scalaire.

        :param      k:       float


        :githublink:`%|py|46`
        """
        self.x *= k
        self.y *= k

    def norme(self) -> float:
        """
        Retourne la norme.

        :return:         float (norm)


        :githublink:`%|py|55`
        """
        return math.sqrt(self.x * self.x + self.y * self.y)

    def as_array(self):
        """
        Convertit en array.


        :githublink:`%|py|61`
        """
        return numpy.array([self.x, self.y])

    def scalaire(self, k: 'Point') -> float:
        """
        Calcule le produit scalaire.

        :param      k:       :class:`Point <mlstatpy.image.detection_segment.geometrie.Point>`
        :return:             float


        :githublink:`%|py|70`
        """
        return self.x * k.x + self.y * k.y

    def __iadd__(self, ad):
        """
ajoute un vecteur à celui-ci

:githublink:`%|py|74`
        """
        self.x += ad.x
        self.y += ad.y
        return self

    def __add__(self, ad):
        """
ajoute un vecteur a celui-ci

:githublink:`%|py|80`
        """
        return Point(self.x + ad.x, self.y + ad.y)

    def arrondi(self) -> 'Point':
        """
        retourne les coordonnées arrondies à l'entier le plus proche


        :githublink:`%|py|86`
        """
        return Point(int(self.x + 0.5), int(self.y + 0.5))

    def __sub__(self, p):
        """
soustraction de deux de vecteurs

:githublink:`%|py|90`
        """
        return Point(self.x - p.x, self.y - p.y)

    def angle(self):
        """
retourne l'angle du vecteur

:githublink:`%|py|94`
        """
        return math.atan2(self.y, self.x)

    def __eq__(self, a) -> bool:
        """
        retourne True si les deux points ``self`` et ``a`` sont egaux,
        False sinon

        :githublink:`%|py|99`
        """
        return self.x == a.x and self.y == a.y


class Segment:
    """
    Définit un segment, soit deux :class:`Point <mlstatpy.image.detection_segment.geometrie.Point>`.


    :githublink:`%|py|106`
    """

    # voir le commentaire associees a la ligne contenant __slots__
    # dans la classe Point
    __slots__ = "a", "b"

    def __init__(self, a, b):
        """
        constructeur, pour éviter des erreurs d'etourderie,
        on crée des copies des extrémités a et b,
        comme ce sont des classes, une simple affectation ne suffit pas


        :githublink:`%|py|117`
        """
        self.a, self.b = copy.copy(a), copy.copy(b)

    def __str__(self) -> str:
        """
permet d'afficher le segment avec l'instruction print

:githublink:`%|py|121`
        """
        return "[{0},{1}]".format(self.a, self.b)

    def directeur(self) -> Point:
        """
        retourne le vecteur directeur du segment,
        ce vecteur est norme

        :githublink:`%|py|126`
        """
        p = Point(self.b.x - self.a.x, self.b.y - self.a.y)
        p.normalise()
        return p

    def normal(self) -> float:
        """
        retourne le vecteur normal du segment,
        ce vecteur est norme

        :githublink:`%|py|133`
        """
        p = Point(self.a.y - self.b.y, self.b.x - self.a.x)
        p.normalise()
        return p

    def first(self):
        """
Retourne la première extrémité.

:githublink:`%|py|139`
        """
        return self.a

    def last(self):
        """
Retourne la seconde extrémité.

:githublink:`%|py|143`
        """
        return self.b