Coverage for src/mlstatpy/image/detection_segment/geometrie.py: 93%

60 statements  

« prev     ^ index     » next       coverage.py v6.4.1, created at 2022-06-13 20:42 +0200

1# -*- coding: utf-8 -*- 

2""" 

3@file 

4@brief Définition de petits éléments géométriques tels que les points 

5et les segments, implemente également des opérations standard 

6telles le produit scalaire entre deux vecteurs, ... 

7""" 

8import math 

9import copy 

10import numpy 

11 

12 

13class Point: 

14 """ 

15 Définit un point de l'image ou un vecteur, 

16 deux coordonnées *x* et *y* qui sont réelles. 

17 """ 

18 __slots__ = "x", "y" 

19 

20 def __init__(self, x, y): 

21 """constructeur""" 

22 self.x = x 

23 self.y = y 

24 

25 def __str__(self): 

26 """permet d'afficher un point avec l'instruction print""" 

27 return '({0},{1})'.format(self.x, self.y) 

28 

29 def __repr__(self): 

30 """usuel""" 

31 return 'Point({0}, {1})'.format(self.x, self.y) 

32 

33 def normalise(self): 

34 """normalise le vecteur, sa norme devient 1""" 

35 v = self.x * self.x + self.y * self.y 

36 v = math.sqrt(v) 

37 if v > 0: # evite les erreurs si sa norme est nulle 

38 self.x /= v 

39 self.y /= v 

40 

41 def scalairek(self, k: float): 

42 """ 

43 Mulitplication par un scalaire. 

44 

45 @param k float 

46 """ 

47 self.x *= k 

48 self.y *= k 

49 

50 def norme(self) -> float: 

51 """ 

52 Retourne la norme. 

53 

54 @return float (norm) 

55 """ 

56 return math.sqrt(self.x * self.x + self.y * self.y) 

57 

58 def as_array(self): 

59 """ 

60 Convertit en array. 

61 """ 

62 return numpy.array([self.x, self.y]) 

63 

64 def scalaire(self, k: 'Point') -> float: 

65 """ 

66 Calcule le produit scalaire. 

67 

68 @param k @see cl Point 

69 @return float 

70 """ 

71 return self.x * k.x + self.y * k.y 

72 

73 def __iadd__(self, ad): 

74 """ajoute un vecteur à celui-ci""" 

75 self.x += ad.x 

76 self.y += ad.y 

77 return self 

78 

79 def __add__(self, ad): 

80 """ajoute un vecteur a celui-ci""" 

81 return Point(self.x + ad.x, self.y + ad.y) 

82 

83 def arrondi(self) -> 'Point': 

84 """ 

85 retourne les coordonnées arrondies à l'entier le plus proche 

86 """ 

87 return Point(int(self.x + 0.5), int(self.y + 0.5)) 

88 

89 def __sub__(self, p): 

90 """soustraction de deux de vecteurs""" 

91 return Point(self.x - p.x, self.y - p.y) 

92 

93 def angle(self): 

94 """retourne l'angle du vecteur""" 

95 return math.atan2(self.y, self.x) 

96 

97 def __eq__(self, a) -> bool: 

98 """retourne True si les deux points ``self`` et ``a`` sont egaux, 

99 False sinon""" 

100 return self.x == a.x and self.y == a.y 

101 

102 

103class Segment: 

104 """ 

105 Définit un segment, soit deux @see cl Point. 

106 """ 

107 

108 # voir le commentaire associees a la ligne contenant __slots__ 

109 # dans la classe Point 

110 __slots__ = "a", "b" 

111 

112 def __init__(self, a, b): 

113 """ 

114 constructeur, pour éviter des erreurs d'etourderie, 

115 on crée des copies des extrémités a et b, 

116 comme ce sont des classes, une simple affectation ne suffit pas 

117 """ 

118 self.a, self.b = copy.copy(a), copy.copy(b) 

119 

120 def __str__(self) -> str: 

121 """permet d'afficher le segment avec l'instruction print""" 

122 return "[{0},{1}]".format(self.a, self.b) 

123 

124 def directeur(self) -> Point: 

125 """retourne le vecteur directeur du segment, 

126 ce vecteur est norme""" 

127 p = Point(self.b.x - self.a.x, self.b.y - self.a.y) 

128 p.normalise() 

129 return p 

130 

131 def normal(self) -> float: 

132 """retourne le vecteur normal du segment, 

133 ce vecteur est norme""" 

134 p = Point(self.a.y - self.b.y, self.b.x - self.a.x) 

135 p.normalise() 

136 return p 

137 

138 def first(self): 

139 """Retourne la première extrémité.""" 

140 return self.a 

141 

142 def last(self): 

143 """Retourne la seconde extrémité.""" 

144 return self.b