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

2""" 

3@file 

4@brief image et synthèse 

5""" 

6 

7from .image_synthese_facette import Rectangle 

8from .image_synthese_base import Rayon, Couleur 

9from .image_synthese_sphere import Sphere 

10 

11 

12class RectangleImage(Rectangle): 

13 """définit un rectangle contenant un portrait""" 

14 

15 def __init__(self, a, b, c, d, nom_image, pygame, invertx=False): 

16 """initialisation, si d == None, d est calculé comme étant 

17 le symétrique de b par rapport au milieu du segment [ac], 

18 la texture est une image, 

19 si invertx == True, inverse l'image selon l'axe des x""" 

20 Rectangle.__init__(self, a, b, c, d, Couleur(0, 0, 0)) 

21 self.image = pygame.image.load(nom_image) 

22 self.nom_image = nom_image 

23 self.invertx = invertx 

24 

25 def __str__(self): 

26 """affichage""" 

27 s = "rectangle image --- a : " + str(self.a) 

28 s += " b : " + str(self.b) 

29 s += " c : " + str(self.c) 

30 s += " d : " + str(self.d) 

31 s += " image : " + self.nom_image 

32 return s 

33 

34 def couleur_point(self, p): 

35 """retourne la couleur au point de coordonnée p""" 

36 ap = p - self.a 

37 ab = self.b - self.a 

38 ad = self.d - self.a 

39 abn = ab.norme2() 

40 adn = ad.norme2() 

41 x = ab.scalaire(ap) / abn 

42 y = ad.scalaire(ap) / adn 

43 sx, sy = self.image.get_size() 

44 k, li = int(x * sx), int(y * sy) 

45 k = min(k, sx - 1) 

46 li = min(li, sy - 1) 

47 li = sy - li - 1 

48 if not self.invertx: 

49 c = self.image.get_at((k, li)) 

50 else: 

51 c = self.image.get_at((sx - k - 1, li)) 

52 cl = Couleur(float(c[0]) / 255, float(c[1]) / 255, float(c[2]) / 255) 

53 return cl 

54 

55 

56class SphereReflet (Sphere): 

57 """implémente une sphère avec un reflet""" 

58 

59 def __init__(self, centre, rayon, couleur, reflet): 

60 """initialisation, reflet est un coefficient de réflexion""" 

61 Sphere.__init__(self, centre, rayon, couleur) 

62 self.reflet = reflet 

63 

64 def __str__(self): 

65 """affichage""" 

66 s = "sphere reflet --- centre : " + str(self.centre) 

67 s += " rayon : " + str(self.rayon) 

68 s += " couleur : " + str(self.couleur) 

69 return s 

70 

71 def rayon_reflechi(self, rayon, p): 

72 """retourne le rayon réfléchi au point p de la surface, 

73 si aucune, retourne None""" 

74 if p == rayon.origine: 

75 return None 

76 n = self.normale(p, rayon) 

77 n = n.renorme() 

78 y = n.scalaire(rayon.direction) 

79 d = rayon.direction - n * y * 2 

80 r = Rayon(p, d, rayon.pixel, rayon.couleur * self.reflet) 

81 return r