def test_angle_entre(self):
""" Vecteur -> Float
Permet de retourner l'angle entre deux vecteurs (en degrés)
"""
v = Vecteur.Vecteur(0,1)
autreVecteur = Vecteur.Vecteur(1, 0)
self.assertTrue(abs(v.angle_entre(autreVecteur)) - 90. <= 0.00001)
def test_dessineVecteur(self):
t = Terrain.Terrain(1000, 1000, 1)
v = Vecteur.Vecteur(random.uniform(100., 200),
random.uniform(100., 200.))
posOrigine = (500., 500.)
t.dessineVecteur(posOrigine, v)
if v.x == 0. and v.y > 0.:
angle = pi / 2
elif v.x == 0. and v.y < 0.:
angle = -pi / 2
else:
angle = atan(v.y / v.x)
if v.x < 0.:
angle += pi
vecteurUnite = Vecteur.Vecteur(
cos(angle) * t.echelle,
sin(angle) * t.echelle)
traceX = posOrigine[0]
traceY = posOrigine[1]
norme = v.norme()
while Vecteur.Vecteur(traceX - posOrigine[0],
traceY - posOrigine[1]).norme() <= norme:
self.assertFalse(t.ajout_objet_continu(object(), traceX, traceY))
traceX += vecteurUnite.x
traceY += vecteurUnite.y
def dessineVecteur(self, posOrigine, vecteur):
if vecteur.x == 0. and vecteur.y > 0.:
angle = pi / 2
elif vecteur.x == 0. and vecteur.y < 0.:
angle = -pi / 2
else:
angle = atan(vecteur.y / vecteur.x)
if vecteur.x < 0.:
angle += pi
vecteurUnite = Vecteur.Vecteur(
cos(angle) * self.echelle,
sin(angle) * self.echelle)
traceX = posOrigine[0]
traceY = posOrigine[1]
norme = vecteur.norme()
while Vecteur.Vecteur(traceX - posOrigine[0],
traceY - posOrigine[1]).norme() <= norme:
self.ajout_objet_continu(object(), traceX, traceY)
traceX += vecteurUnite.x
traceY += vecteurUnite.y
def test__add__(self):
for _ in range(1000):
v1 = Vecteur.Vecteur(random.randint(-500, 500), random.randint(-500, 500))
v2 = Vecteur.Vecteur(random.randint(-500, 500), random.randint(-500, 500))
vv = v1.__add__(v2)
self.assertTrue(vv.x == v1.x + v2.x)
self.assertTrue(vv.y == v1.y + v2.y)
def test_collision(self):
""" Tuple(x1,y1) * Vecteur * Tuple(x2,y2) -> Boolean
Permet de dire s'il y a collision entre deux vecteurs
"""
v = Vecteur.Vecteur(0,1)
autreVecteur = Vecteur.Vecteur(1, 0)
self.assertTrue(v.collision((0.,0.), autreVecteur, (0.,0.)))
v.y = -1.
self.assertTrue(v.collision((0.,0.), autreVecteur, (0.,0.)))
autreVecteur.x = -1
self.assertTrue(v.collision((0.,0.), autreVecteur, (0.,0.)))
def test_collision(self):
"""tuple(int * int) * Vecteur -> boolean
methode qui verifie la collision du robot avec un objet.
"""
liste_sommets = []
for _ in range(20):
liste_sommets.append(
(random.uniform(10., 50.), random.uniform(10., 50.)))
p = Polygone.Polygone(liste_sommets)
posRobot = (random.uniform(10., 50.), random.uniform(10., 50.))
vD = Vecteur.Vecteur(random.uniform(10., 50.),
random.uniform(10., 50.))
bo = False
i = 0
while i < len(p._liste_sommet):
if p.liste_vecteur[i].collision(p._liste_sommet[i], vD, posRobot):
bo = True
break
i = i + 1
self.assertTrue(bo == p.collision(posRobot, vD))
def is_polygone(self, polygone):
v = Vecteur.Vecteur(0., 0.)
for vp in polygone.liste_vecteur:
v = v + vp
self.assertTrue(abs(v.x) <= 0.00001 and abs(v.y) <= 0.00001)
def test_constructVecteur(self):
random_x = random.randint(-500, 500)
random_y = random.randint(-500, 500)
V = Vecteur.Vecteur(random_x, random_y)
self.assertTrue(V.x == random_x)
self.assertTrue(V.y == random_y)
def test_collision(self):
"""tuple (int * int) * Vecteur -> boolean
méthode qui verifie la collision du robot avec les objets contenu sur le terrain ainsi qu'avec
les vecteurs qui le delimitent
: param tuple : coordonnees du robot
: param Vecteur : vecteur de deplacement du robot
"""
tc = TerrainContinu.Carre(20)
tc.ajoutPolygone(Polygone.Carre((10., 10.), 5))
posOrigine = (3., 3.)
vecteurDeplacement = Vecteur.Vecteur(random.uniform(-10., 10.),
random.uniform(-10., 10.))
b = False
for p in tc.listePolygone:
if p.collision(posOrigine, vecteurDeplacement):
b = True
# posX, posY : position du premier vecteur du terrain
posX = tc.polygoneSurface.liste_sommet[0].x
posY = tc.polygoneSurface.liste_sommet[1].y
for v in tc.polygoneSurface.liste_vecteur:
# vecteurDeplacement et (x,y) du robot
if v.collision((posX, posY), vecteurDeplacement, posOrigine):
b = True
# calcul de l'origine des vecteurs suivants
posX = posX + v.x
posY = posY + v.y
self.assertTrue(b == tc.collision(posOrigine, vecteurDeplacement))
def getDistance(self, tc):
vUnitaire = Vecteur.Vecteur(
cos(radians(self.angle)) * 1,
sin(radians(self.angle)) * 1)
while not tc.collision((self.x, self.y), vUnitaire):
vUnitaire += vUnitaire
return vUnitaire.norme()
def test_rotation(self):
rx = random.randint(-50, 50)
ry = random.randint(-50, 50)
v = Vecteur.Vecteur(rx, ry)
angle = random.uniform(-180, 180)
v = v.rotation(angle)
vx = rx * math.cos(math.radians(angle)) - ry * math.sin(math.radians(angle))
vy = rx * math.sin(math.radians(angle)) + ry * math.cos(math.radians(angle))
self.assertLessEqual(abs(v.x - vx), 0.00001)
self.assertLessEqual(abs(v.y - vy), 0.00001)
def test_Sym_XVecteur(self):
rx = random.randint(-50, 50)
ry = random.randint(-50, 50)
v1 = Vecteur.Vecteur(rx, ry)
v2 = v1.get_sym_x_axis()
v3 = v1 + v2
self.assertEqual(v1.norme(), v2.norme())
self.assertEqual(v1.x, v2.x)
self.assertEqual(v3.x, 2 * v1.x)
self.assertEqual(v3.y, 0)
def __init__(self, liste_sommet, liste_vecteur=None):
if liste_vecteur is None:
liste_vecteur = []
self.liste_vecteur = liste_vecteur
self._liste_sommet = liste_sommet
self.liste_sommet = []
for s in liste_sommet:
self.liste_sommet.append(Sommet.Sommet(s[0], s[1]))
if not self.liste_vecteur:
for i in range(len(liste_sommet) - 1):
x1, y1 = liste_sommet[i]
x2, y2 = liste_sommet[i + 1]
v = Vecteur.Vecteur((x2 - x1), (y2 - y1))
self.liste_vecteur.append(v)
x0, y0 = liste_sommet[len(liste_sommet) - 1]
xn, yn = liste_sommet[0]
v = Vecteur.Vecteur((xn - x0), (yn - y0))
self.liste_vecteur.append(v)
def test_produitVecteurScalaire(self):
# tests pour un scalaire entier
for _ in range(10):
aleaX = random.randint(-500, 500)
aleaY = random.randint(-500, 500)
v = Vecteur.Vecteur(aleaX, aleaY)
scalaire = random.randint(-500, 500)
vScalaire = v.__mul__(scalaire)
vtest = Vecteur.Vecteur(aleaX * scalaire, aleaY * scalaire)
self.assertTrue(vScalaire.x == vtest.x)
self.assertTrue(vScalaire.y == vtest.y)
# tests pour un scalaire flottant
for _ in range(10):
aleaX = random.uniform(-500, 500)
aleaY = random.uniform(-500, 500)
v = Vecteur.Vecteur(aleaX, aleaY)
scalaire = random.randint(-500, 500)
vScalaire = v.__mul__(scalaire)
vtest = Vecteur.Vecteur(aleaX * scalaire, aleaY * scalaire)
self.assertTrue(vScalaire.x == vtest.x)
self.assertTrue(vScalaire.y == vtest.y)
def test_symXVecteur(self):
for _ in range(1000):
rx = random.randint(-50, 50)
ry = random.randint(-50, 50)
v1 = Vecteur.Vecteur(rx, ry)
v2 = v1.get_sym_x_axis()
v3 = v1 + v2
self.assertTrue(v1.norme() == v2.norme()) # test norme vecteur et son symetrique (Ox) sont identiques
self.assertTrue(v1.x == v2.x) # test que l'abscisse ne change pas dans le symetrique (Ox)
self.assertTrue(v3.x == 2 * v1.x) # test prop. somme vect. et son sym.(Oy) => abscisseX somme est doublé
self.assertTrue(v3.y == 0) # test prop. somme vect. et son sym.(Ox) => ordonnéeY somme est nulle
def test_normeVecteur(self):
# test calcul norme vecteur avec des valeurs positives
for _ in range(100):
aleaX = random.randint(0, 1000)
aleaY = random.randint(0, 1000)
v = Vecteur.Vecteur(aleaX, aleaY)
self.assertTrue(v.norme() == math.sqrt(aleaX * aleaX + aleaY * aleaY))
# test calcul norme vecteur avec des valeurs negatives
for _ in range(100):
aleaX = random.randint(-1000, 0)
aleaY = random.randint(-1000, 0)
v = Vecteur.Vecteur(aleaX, aleaY)
self.assertTrue(v.norme() == math.sqrt(aleaX * aleaX + aleaY * aleaY))
# test calcul norme vecteur avec des valeurs positives et/ou negatives
for _ in range(100):
aleaX = random.randint(-500, 500)
aleaY = random.randint(-500, 500)
v = Vecteur.Vecteur(aleaX, aleaY)
self.assertTrue(v.norme() == math.sqrt(aleaX * aleaX + aleaY * aleaY))
def setUp(self):
self.v1 = Vecteur.Vecteur(4, 7)
self.v2 = Vecteur.Vecteur(7, -3)
def test_norme(self):
aleaX = random.randint(-100, 100)
aleaY = random.randint(-100, 100)
v = Vecteur.Vecteur(aleaX, aleaY)
self.assertEqual(v.x, aleaX)
self.assertEqual(v.y, aleaY)
def vitesse(self, vitesse):
self.vecteurDeplacement = Vecteur.Vecteur(
cos(radians(self.angle)) * vitesse,
sin(radians(self.angle)) * vitesse)
self._vitesse = vitesse
