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 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 test_rotate_all_around(self):
p = Point(
random.choice([1, -1]) * random.randint(0, 5),
random.choice([1, -1]) * random.randint(0, 5),
random.choice([1, -1]) * random.randint(0, 5)) + self.r.centre
teta = random.random() * 2 * pi * random.choice([1, -1])
f = self.r.forme.clone()
c = self.r.centre.clone()
rg = self.r.rg.clone()
rd = self.r.rd.clone()
v = self.r.direction.clone()
print(v)
self.r.rotate_all_around(p, teta)
rd.rotate_around(p, teta)
rg.rotate_around(p, teta)
f.rotate_all_around(p, teta)
c.rotate_around(p, teta)
v.rotate(teta)
self.assertEqual(self.r.direction, v)
self.assertEqual(self.r.forme, f)
self.assertEqual(self.r.centre, c)
self.assertEqual(self.r.direction, v)
self.assertEqual(self.r.rd, rd)
self.assertEqual(self.r.rg, rg)
def test_rotate_around(self):
"""
Teste la rotation
TODO: Il y à un problème quand la coordonnée z est non nulle
TODO: Peut être très imprécis dans certains cas, à corriger, ou trouver les cas pathologiques
"""
print("Testing rotate_around...")
s = [-1, 1]
p = Point(
rm.choice(s) * rm.randint(2, 5),
rm.choice(s) * rm.randint(2, 5), 0)
teta = rm.random() * rm.choice(s) * pi
v = (self.dot - p).to_vect()
n = v.get_mag()
aux = (v * 100).rotate(teta)
aux = aux * n / aux.get_mag() + p
self.dot.rotate_around(p, teta)
v2 = (aux.to_point() - p).to_vect()
d_dist = abs(v.get_mag() - v2.get_mag())
d_angle = v.diff_angle(v2, signe=1)
self.assertAlmostEqual(d_angle,
fonctions.positive_angle(teta),
msg="Error angle")
self.assertAlmostEqual(d_dist, 0, msg="Error distance")
print("Done")
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__"] == Point.__name__:
return Point.hook(dct)
elif dct["__class__"] == Pave.__name__:
return Pave(
dct["width"], dct["length"], dct["height"], dct["centre"],
[dct["vertices"][i] for i in range(len(dct["vertices"]))])
def hook(dct):
if dct["__class__"] == Point.__name__:
return Point.hook(dct)
elif dct["__class__"] == Polygone3D.__name__:
return Polygone3D(centre=dct["centre"],
vertices=[
dct["vertices"][i]
for i in range(len(dct["vertices"]))
])
def test_json(self):
print("Testing json format...")
try:
self.dot.save("dot.json")
d2 = Point.load("dot.json")
self.assertEqual(self.dot, d2)
except PermissionError:
print("Permission Error")
print("Done")
def __init__(self,
centre: Point = Point(0, 0, 0),
direction: Vecteur = Vecteur(1, 0, 0),
portee: int or float = 3,
arena_v=None,
l_ignore=list()):
Capteur.__init__(self, centre=centre, direction=direction)
self.portee = portee
self.arena_v = arena_v
self.l_ignore = l_ignore
def __init__(self, centre=Point(0, 0, 0), vertices=list()):
"""
Initialise la liste des sommets
:param centre: Centre du polygône
:type centre: Point
:param vertices: Centre du polygône
:type vertices: [Point]
"""
Objet3D.__init__(self, centre=centre)
self.vertices = vertices
def hook(dct):
""" On ne copie pas la liste d'objets à ingorer"""
if dct["__class__"] == Point.__name__:
return Point.hook(dct)
elif dct["__class__"] == Vecteur.__name__:
return Vecteur.hook(dct)
elif dct["__class__"] == Arene.__name__:
return Arene.hook(dct)
elif dct["__class__"] == VueMatriceArene.__name__:
return VueMatriceArene(dct["arene"], dct["origine"], dct["ox"],
dct["ajuste"], dct["matrice"])
def test_add_list(self):
self.a.empty()
l = [Objet3D(Point(0, 0, 0)).clone() for i in range(self.n)]
self.a.add_list(l)
self.assertEqual(len(l), len(self.a.objets3D))
for i in range(self.n):
self.a.objets3D[i].centre.move(Vecteur(1, 0, 0))
self.assertNotEqual(l[0], self.a.objets3D[0])
def __init__(self, centre=Point(0, 0, 0), diametre=0.5, height=1):
"""
:param centre: Centre du cylindre
:type centre: Point
:param diametre: Diametre du cylindre
:type diametre: float
:param height: Hauteur du cylindre
:type height: float
"""
Objet3D.__init__(self, centre)
self.diametre = diametre
self.height = height
class TestDroitVersBalise(unittest.TestCase):
"""
TODO: S'arranger pour que la direction u capteur ir suive bien celle de la tête
"""
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 test_target_straith_trajectory(self):
self.strat2 = DeplacementDroit(robot=self.target,vitesse= 30, distance_max=2)
td = Thread(target=self.strat.start_3D)
sim = Simulation(strategies=[self.strat2, self.strat], tmax=15, tic=3,
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
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 __init__(self,
width: float or int,
length: float or int,
height: float or int,
centre=Point(0, 0, 0),
vertices: [Point] = None):
"""
Constructeur ajoutant les 8 sommets autour du centre par défaut: (0,0,0)
"""
Polygone3D.__init__(self, centre, vertices)
self.width = float(width)
self.length = float(length)
self.height = float(height)
if vertices is None:
self.vertices = list()
self.add_vertex(
Point(self.centre.x - width / 2, self.centre.y - length / 2,
self.centre.z + height / 2))
self.add_vertex(
Point(self.centre.x + width / 2, self.centre.y - length / 2,
self.centre.z + height / 2))
self.add_vertex(
Point(self.centre.x + width / 2, self.centre.y + length / 2,
self.centre.z + height / 2))
self.add_vertex(
Point(self.centre.x - width / 2, self.centre.y + length / 2,
self.centre.z + height / 2))
self.add_vertex(
Point(self.centre.x - width / 2, self.centre.y - length / 2,
self.centre.z - height / 2))
self.add_vertex(
Point(self.centre.x + width / 2, self.centre.y - length / 2,
self.centre.z - height / 2))
self.add_vertex(
Point(self.centre.x + width / 2, self.centre.y + length / 2,
self.centre.z - height / 2))
self.add_vertex(
Point(self.centre.x - width / 2, self.centre.y + length / 2,
self.centre.z - height / 2))
def __init__(self,
arene: Arene,
origine=Point(0, 0, 0),
ox=Vecteur(1, 0, 0),
ajuste=False):
"""Initialise la vue de la matrice
:param arene: Arène à analyser
:param origine: Origine O du repère de la vue
:param ox: Vecteur Ox unitaire de ce même repère
:param ajuste: A True, à l'analyse, prends Ox tourné de -45, pour centrer la vue
"""
self.origine = origine
self.arene = arene
self.ox = ox
self.ajuste = ajuste
self.matrix = None
def __init__(self,
arene: Arene = Arene(),
origine: Point = Point(0, 0, 0),
ox: Vecteur = Vecteur(1, 0, 0),
ajuste: bool = False,
matrice: [[int]] = None):
"""
Initialise la matrice
:param arene: Arène dont on prélève une portion
:param origine: Origine de la vue, dans le repère de l'arène
:param ox: Direction horizontale de la vue, dans le repère de l'arène
:param ajuste: On représente la matrice selon Ox tourné de -45 degrés dans le sens trigonométrique
"""
self.origine = origine
self.arene = arene
self.ox = ox
self.ajuste = ajuste
self.matrice = matrice # Destiné à stocker la dernière matrice crée
def test_rotate_around(self):
p = Point(
random.choice([1, -1]) * random.randint(0, 5),
random.choice([1, -1]) * random.randint(0, 5),
random.choice([1, -1]) * random.randint(0, 5)) + self.r.centre
teta = random.random() * 2 * pi * random.choice([1, -1])
f = self.r.forme.clone()
c = self.r.centre.clone()
rg = self.r.rg.clone()
rd = self.r.rd.clone()
self.r.rotate_around(p, teta)
rd.centre.rotate_around(p, teta)
rg.centre.rotate_around(p, teta)
f.centre.rotate_around(p, teta)
c.rotate_around(p, teta)
self.assertEqual(self.r.forme.centre, f.centre)
self.assertEqual(self.r.centre, c)
self.assertEqual(self.r.rd.centre, rd.centre)
self.assertEqual(self.r.rg.centre, rg.centre)
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")
def __init__(self,
centre: Point = Point(0, 0, 0),
direction: Vecteur = Vecteur(1, 0, 0)):
Objet3D.__init__(self, centre)
self.direction = direction
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.dot = Point(1, 1, 0)
: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)
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)
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)
return s
def get_inclinaisont(self):
"""
Retourne la différence d'angle entre un des côtés du pavé sur le plan Oxy, et le vecteur (1,0,0)
"""
return (self.vertices[1] - self.vertices[0]).to_vect().diff_angle(
Vecteur(1, 0, 0))
@staticmethod
def load(filename):
with open(filename, 'r', encoding='utf-8') as f:
return json.load(f, object_hook=Pave.hook)
@staticmethod
def hook(dct):
if dct["__class__"] == Point.__name__:
return Point.hook(dct)
elif dct["__class__"] == Pave.__name__:
return Pave(
dct["width"], dct["length"], dct["height"], dct["centre"],
[dct["vertices"][i] for i in range(len(dct["vertices"]))])
def get_pave(self):
return self
if __name__ == '__main__':
p = Pave(150, 200, 0, Point(50, 50, 0))
print(p)
:param point: Point autour duquel tourner
:type point: Point
:param teta: Angle en radians
:type teta: float
:param axis: 'z', 'x' ou 'y'
"""
self.centre.rotate_around(point, teta, axis)
@staticmethod
def hook(dct):
if dct["__class__"] == Objet3D.__name__:
return Objet3D(dct["centre"])
elif dct["__class__"] == Point.__name__:
return Point.hook(dct)
@staticmethod
def load(filename):
with open(filename, 'r', encoding='utf-8') as f:
return json.load(f, object_hook=Objet3D.hook)
if __name__ == '__main__':
o = Objet3D(Point(0, 0, 0))
o.save("objet3D.json")
o2 = Objet3D.load("objet3D.json")
print(o2)
for i in range(len(dct["vertices"]))
])
@staticmethod
def load(filename):
"""
Permet de charger un objet Polygône3D depuis un fichier au format json adapté
:param filename: Nom du fichier
"""
with open(filename, 'r', encoding='utf-8') as f:
return json.load(f, object_hook=Polygone3D.hook)
def clone(self):
d = self.__dict__()
return Polygone3D(centre=d["centre"], vertices=d["vertices"])
if __name__ == '__main__':
from gl_lib.sim.geometry import *
p = Polygone3D(vertices=[Point(1, 1, 1)])
d = p.__dict__()
p.save("polygone3D.json")
p2 = Polygone3D.hook(d)
print(p2)
p3 = Polygone3D.load("polygone3D.json")
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 hook(dct):
if dct["__class__"] == Objet3D.__name__:
return Objet3D(dct["centre"])
elif dct["__class__"] == Point.__name__:
return Point.hook(dct)