def __init__(self, pave, canevas):
"""
Crée une copie du pavé en argument à la bonne échelle pour l'affichage 2D, puis le convertis en lignes tkinter
Il est supposé que les sommets du pave sont rangés dans le bon ordre (anti-horaire) et que les 4 premiers sont
les plus hauts
:param pave: Pavé à représenter
:type pave: Pave
:param canevas: Canevas sur lequel dessiner
:type canevas: Canvas
"""
Vue2D.__init__(self)
self.pave = Pave(width=pave.width * PIX_PAR_M_2D,
length=pave.length * PIX_PAR_M_2D,
height=pave.height * PIX_PAR_M_2D,
centre=pave.centre * PIX_PAR_M_2D)
self.pave.rotate(
(pave.vertices[1] - pave.vertices[0]).to_vect().get_angle())
self.cotes = list()
for i in range(0, 3):
self.cotes.append(
canevas.create_line(pave.vertices[i].x, pave.vertices[i].y,
pave.vertices[i + 1].x,
pave.vertices[i + 1].y))
self.cotes.append(
canevas.create_line(pave.vertices[3].x, pave.vertices[3].y,
pave.vertices[0].x, pave.vertices[0].y))
def test_vue_dessus(self):
"""
On ajoute à l'arène un pavé de dimensions (1,1,1) dans l'axe Ox de la vue,
à une distance comprise entre 1 et 5 mètres
S'assure qu'on a bien une matrice carrée, de la bonne taille
contenant des entiers, et qu'elle a bien détecté un pavé dans la zone
"""
teta2 = random.random() * random.choice(
[1, -1]) * 2 * pi # Angle de rotation du pavé
self.dist = random.randint(
1,
5) # Distance qu'on va mettre entre l'origine et le centre du pavé
self.p = Pave(1, 1, 1,
self.view_mat.origine + self.view_mat.ox * self.dist)
self.p.rotate(teta2)
self.arene.add(self.p)
print("Evaluatin view of:\n", self.p, "\n")
dx = self.dist + max(
self.p.width, self.p.length) # On s'assure d'englober tout le pavé
m = self.view_mat.vueDessus(dx)
self.assertEqual(len(m), int(dx * VueMatriceArene.res))
if self.view_mat is not None:
print(repr(self.view_mat))
for i in range(len(m)):
for j in range(len(m[0])):
self.assertIsInstance(m[i][j], int)
self.assertEqual(len(m), len(m[0]))
class TestVueMatriceArene(unittest.TestCase):
"""
Cette classe sert à tester la vue matricielle d'un pavé
On crée une vue matricielle d'une arène dans une direction aléatoire, à une position aléatoire
On prend pour les tests des distancees entre 1 et 5 mètres
"""
def setUp(self):
self.arene = Arene()
# Création aléatoire des variables
l = [random.randint(1, 5) * random.choice([1, -1]) for i in range(2)]
origine = Point(l[0], l[1], 0)
teta = random.random() * random.choice(
[1, -1]) * 2 * pi # Angle du vecteur entre l'origine et le pavé
v = Vecteur(1, 0, 0).rotate(teta).norm()
# True est obligatoire pour que test_vue_dessus affiche le pavé au centre
self.view_mat = VueMatriceArene(self.arene, origine.clone(), v.clone(),
True)
def test_init(self):
self.assertIsInstance(self.view_mat.origine, Point)
self.assertIsInstance(self.view_mat.arene, Arene)
self.assertIsInstance(self.view_mat.ox, Vecteur)
self.assertIsInstance(self.view_mat.ajuste, bool)
def test_vue_dessus(self):
"""
On ajoute à l'arène un pavé de dimensions (1,1,1) dans l'axe Ox de la vue,
à une distance comprise entre 1 et 5 mètres
S'assure qu'on a bien une matrice carrée, de la bonne taille
contenant des entiers, et qu'elle a bien détecté un pavé dans la zone
"""
teta2 = random.random() * random.choice(
[1, -1]) * 2 * pi # Angle de rotation du pavé
self.dist = random.randint(
1,
5) # Distance qu'on va mettre entre l'origine et le centre du pavé
self.p = Pave(1, 1, 1,
self.view_mat.origine + self.view_mat.ox * self.dist)
self.p.rotate(teta2)
self.arene.add(self.p)
print("Evaluatin view of:\n", self.p, "\n")
dx = self.dist + max(
self.p.width, self.p.length) # On s'assure d'englober tout le pavé
m = self.view_mat.vueDessus(dx)
self.assertEqual(len(m), int(dx * VueMatriceArene.res))
if self.view_mat is not None:
print(repr(self.view_mat))
for i in range(len(m)):
for j in range(len(m[0])):
self.assertIsInstance(m[i][j], int)
self.assertEqual(len(m), len(m[0]))
def setUp(self):
c = Point(2, 2, 1)
v = Vecteur(1, 0, 0)
dist = 3.0
self.arene = Arene()
self.strat = DeplacementDroitAmeliore(robot=RobotMotorise(
forme=Pave(1, 1, 1, c.clone()), direction=v.clone()),
arene=self.arene)
self.v = self.strat.robot.direction * dist
self.p = Pave(0.5, 0.5, 0.5, self.strat.robot.centre + self.v)
self.arene.add(self.p)
self.arene.add(self.strat.robot)
def setUp(self):
self.distance = 1
self.strat = DeplacementDroit(
robot=RobotMotorise(forme=Pave(1, 1, 1, Point(3, 3, 0))),
distance_max=self.distance)
self.arene = Arene()
self.arene.add(self.strat.robot)
def hook(dct):
if dct["__class__"] == Vecteur.__name__:
return Vecteur.hook(dct)
elif dct["__class__"] == Roue.__name__:
return Roue.hook(dct)
elif dct["__class__"] == Pave.__name__:
return Pave.hook(dct)
elif dct["__class__"] == Robot.__name__:
return Robot(**dct)
def test_target_circle_trajectectory(self):
self.strat = DroitVersBaliseVision(RobotMotorise(forme=Pave(1,1,1,self.p0.clone()), direction=self.v2.clone()), AreneFermee(10,10,10))
self.strat2 = DeplacementCercle(robot=self.target,vitesse=30, diametre=3, angle_max=360)
td = Thread(target=self.strat.start_3D)
sim = Simulation(strategies=[self.strat2, self.strat], tmax=15, tic=1,tic_display=[self.strat], final_actions=[self.strat.stop_3D])
td.start()
while not self.strat.robot.tete.sensors["cam"].is_set:
pass
sim.start()
while not sim.stop:
pass
self.assertNotEqual(self.strat.last_detected, None)
def test_json(self):
p = Pave(150, 200, 0)
p.save("pave.json")
dct = p.__dict__()
p3 = Pave.load("pave.json")
os.system('rm pave.json')
def test_view(self):
"""
Affiche une arène vide en 3D, effectue quelques rotations
"""
print("Testing video...")
td = Thread(target=self.obj.run)
p = RobotTarget(forme=Pave(1, 1, 1, Point(3, 3, 0.5)))
a = Arene()
a.add(p)
n_rot = 100
teta = 2 * pi / n_rot
self.obj.direction = (p.centre - self.obj.centre).to_vect().norm()
td.start()
while not self.obj.is_set:
pass
for i in range(n_rot):
p.rotate_all_around(p.centre, teta)
sleep(PAS_TEMPS)
self.obj.stop()
print("Done")
class TestPave(unittest.TestCase):
def setUp(self):
self.p = Pave(random.randint(1, 5), random.randint(1, 5),
random.randint(1, 5))
print(self.p)
def test_initialisation(self):
self.assertIsInstance(self.p, Pave, msg=None)
self.assertIsInstance(self.p.length, float, msg=None)
self.assertIsInstance(self.p.width, float, msg=None)
self.assertIsInstance(self.p.height, float, msg=None)
for v in self.p.vertices:
self.assertIsInstance(v, Point, None)
self.assertEqual(len(self.p.vertices), 8, None)
def test_clone(self):
p = self.p.clone()
self.assertEqual(p, self.p, None)
def test_eq(self):
p = self.p.clone()
self.assertEqual(p, self.p, None)
v = Vecteur(
random.randint(1, 5) * random.choice([1, -1]),
random.randint(1, 5) * random.choice([1, -1]),
random.randint(1, 5) * random.choice([1, -1]))
p = self.p.clone().move(v)
self.assertNotEqual(p, self.p, None)
def test_rotate_around(self):
v = Vecteur(
random.randint(0, 5) * random.choice([1, -1]),
random.randint(0, 5) * random.choice([1, -1]),
random.randint(0, 5) * random.choice([1, -1]))
teta = random.choice([1, -1]) * random.random() * 2 * pi
v2 = (self.p.vertices[1] - self.p.vertices[0]).to_vect()
self.p.rotate_around(self.p.centre + v, teta)
angle = v2.get_angle() - (self.p.vertices[1] -
self.p.vertices[0]).to_vect().get_angle()
self.assertLess(abs(angle) % pi, 0.001, None)
p = self.p.clone()
n_centre = (self.p.centre +
v) + (self.p.centre -
(self.p.centre + v)).to_vect().rotate(teta)
v = n_centre - self.p.centre
self.assertEqual(p.move(v), self.p, None)
def test_rotate_all_around(self):
v = Vecteur(
random.randint(0, 5) * random.choice([1, -1]),
random.randint(0, 5) * random.choice([1, -1]),
random.randint(0, 5) * random.choice([1, -1]))
teta = random.choice([1, -1]) * random.random() * 2 * pi
v2 = (self.p.vertices[1] - self.p.vertices[0]).to_vect()
self.p.rotate_all_around(self.p.centre + v, teta)
angle = v2.get_angle() - (self.p.vertices[1] -
self.p.vertices[0]).to_vect().get_angle()
# On veut une précision au millième
self.assertLess(abs(abs(angle) % pi - abs(teta) % pi), 0.001, None)
def test_json(self):
p = Pave(150, 200, 0)
p.save("pave.json")
dct = p.__dict__()
p3 = Pave.load("pave.json")
os.system('rm pave.json')
def clone(self):
l=list()
if len(self.objets3D)>0:
l=[self.objets3D[i].clone() for i in range(len(self.objets3D))]
return Arene(l,self.centre.clone())
@staticmethod
def hook(dct):
if dct["__class__"]==Point.__name__:
return Point.hook(dct)
elif dct["__class__"]==Pave.__name__:
return Pave.hook(dct)
elif dct["__class__"]==Arene.__name__:
return Arene(dct["objets3D"], dct["centre"])
@staticmethod
def load(filename):
with open(filename, 'r', encoding='utf-8') as f:
return json.load(f, object_hook=Arene.hook)
if __name__ == '__main__':
from gl_lib.sim.geometry import Pave
a = Arene([Pave(1,1,1)])
a.save("arene.json")
d=a.__dict__()
a2 = Arene.load("arene.json")
print(a2)
def setUp(self):
self.v2 = Vecteur(1,0,0)
self.p0 = Point(1,1,0.5)
self.strat = DroitVersBaliseVision(RobotMotorise(forme=Pave(1,1,1,self.p0.clone()), direction=self.v2.clone()), AreneFermee(5,5,5))
self.target = RobotTarget(forme=Pave(1,1,1, self.p0.clone()+self.v2*3), direction=self.v2.clone())
self.strat.arene.add(self.target)
def setUp(self):
self.angle = rm.random() * rm.choice([-1, 1]) * pi
self.strat = Tourner(robot=RobotMotorise(Pave(1,1,1,Point(2,2,0))), angle_max=(self.angle * 180 / pi))
self.arene = Arene()
self.arene.add(self.strat.robot)
def setUp(self):
self.r = RobotMotorise(pave=Pave(1, 1, 0, centre=Point(5, 5, 0)),
direction=Vecteur(1, 0, 0))
def setUp(self):
self.p = Pave(random.randint(1, 5), random.randint(1, 5),
random.randint(1, 5))
print(self.p)
class Robot(Objet3D, ApproximableAPave):
"""
Classe definissant les elements essentiels d'un robot
"""
KEYS = ["direction", "forme", "rg", "rd"]
INIT = {
"direction": Vecteur(0, 1, 0),
"forme": Pave(1, 1, 1, Point(0, 0, 0)),
"rg": Objet3D(),
"rd": Objet3D()
}
def __init__(self, **kwargs):
"""
Initialise les attributs, et place les roues par rapport à la direction
On place les roues de part et d'autre de la direction, à 45°
:param forme: Forme du robot
:type forme: Pave
:param rg: Roue droite, représentée comme un point
:type rg: Objet3D
:param rd: Roue gauche, représentée comme un point
:type rd: Objet3D
:param direction: Direction du robot
:type direction: Vecteur
"""
Objet3D.__init__(self)
keys = kwargs.keys()
for key in Robot.INIT.keys():
if not key in keys:
kwargs[key] = Robot.INIT[key]
self.direction = kwargs["direction"]
self.forme = kwargs["forme"]
self.rd = kwargs["rd"]
self.rg = kwargs["rg"]
self.forme.rotate(self.direction.get_angle())
self.centre = self.forme.centre # initalise le centre au centre du pave
self.forme.centre = self.centre
# initialisation des centres des roues
self.rd.centre = self.centre + (self.direction.rotate(-pi / 4) *
self.forme.width * sqrt(2) / 2)
self.rg.centre = self.centre + (self.direction.rotate(pi / 4) *
self.forme.width * sqrt(2) / 2)
self.dist_wheels = self.forme.width
def __dict__(self):
dct = OrderedDict()
dct["__class__"] = Robot.__name__
dct["direction"] = self.direction.__dict__()
dct["forme"] = self.forme.__dict__()
dct["rg"] = self.rg.__dict__()
dct["rd"] = self.rd.__dict__()
return dct
def __str__(self):
s = "{}; direction: {}; forme: {}".format(self.__class__.__name__,
self.direction, self.forme)
return s
def __eq__(self, other):
if not Objet3D.__eq__(self, other):
return False
if other.forme != self.forme:
return False
if other.rd != self.rd or other.rg != self.rg:
return False
if other.direction != self.direction:
return False
if other.dist_wheels != self.dist_wheels:
return False
return True
def rotate_around(self, point, angle, axis=None):
"""
Tourne le robot autour de point d'un angle angle en radians
:param point: Point autour duquel tourner
:type point: Point
:param teta: Angle en radians
:type teta: float
:param axis: 'x', 'y' ou 'z'
"""
self.forme.rotate_around(point, angle, axis)
self.rd.rotate_around(point, angle, axis)
self.rg.rotate_around(point, angle, axis)
def rotate_all_around(self, point, angle, axis=None):
"""
Tourne le Robot et sa direction par rapport à son centre, et autour de point d'un angle en radians
:param point: Point autour duquel tourner
:type point: Point
:param teta: Angle en radians
:type teta: float
:param axis: 'x', 'y' ou 'z'
"""
Objet3D.rotate_around(self, point, angle, axis)
self.forme.rotate_all_around(point, angle, axis)
self.rg.rotate_around(point, angle, axis)
self.rd.rotate_around(point, angle, axis)
self.direction.rotate(angle, axis)
def move(self, vecteur):
"""
Déplace les composants du robot
:param vecteur: Vecteur Déplacement
:type vecteur: Vecteur
"""
self.forme.move(vecteur)
self.rg.move(vecteur)
self.rd.move(vecteur)
def get_pave(self):
return self.forme.get_pave()
@staticmethod
def load(filename):
with open(filename, 'r', encoding='utf-8') as f:
return json.load(f, object_hook=Robot.hook)
@staticmethod
def hook(dct):
if dct["__class__"] == Vecteur.__name__:
return Vecteur.hook(dct)
elif dct["__class__"] == Roue.__name__:
return Roue.hook(dct)
elif dct["__class__"] == Pave.__name__:
return Pave.hook(dct)
elif dct["__class__"] == Robot.__name__:
return Robot(**dct)
:param vecteur: Vecteur Déplacement
:type vecteur: Vecteur
"""
self.forme.move(vecteur)
self.rg.move(vecteur)
self.rd.move(vecteur)
def get_pave(self):
return self.forme.get_pave()
@staticmethod
def load(filename):
with open(filename, 'r', encoding='utf-8') as f:
return json.load(f, object_hook=Robot.hook)
@staticmethod
def hook(dct):
if dct["__class__"] == Vecteur.__name__:
return Vecteur.hook(dct)
elif dct["__class__"] == Roue.__name__:
return Roue.hook(dct)
elif dct["__class__"] == Pave.__name__:
return Pave.hook(dct)
elif dct["__class__"] == Robot.__name__:
return Robot(**dct)
if __name__ == '__main__':
r = Robot(forme=Pave(1, 1, 1, Point(30, 30, 0)))
print(r.forme)
