class TestVectorSetMethods(unittest.TestCase):
# define useful testing nodes
parent_node = Node(0)
n1 = Node(1)
n2 = Node(2)
# define useful testing vectors
vP1 = Vector((parent_node, n1))
vP2 = Vector((parent_node, n2))
v12 = Vector((n1, n2))
def test_len_0(self):
vs = VectorSet(self.parent_node)
self.assertEqual(len(vs), 0)
def test_add(self):
vs = VectorSet(self.parent_node)
try:
vs.add(self.vP1)
except ValueError as ve:
self.fail(ve.args)
def test_add_repeat_vector(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
self.assertEqual(vs.add(self.vP1), False)
def test_len_same_after_failed_add(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
length = len(vs)
vs.add(self.vP1)
self.assertEqual(len(vs), length)
def test_remove_succeed(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
self.assertEqual(vs.remove(self.vP1), True)
def test_remove_failure(self):
vs = VectorSet(self.parent_node)
self.assertEqual(vs.remove(self.vP1), False)
def test_in_true(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
self.assertEqual(self.vP1 in vs, True)
def test_in_false(self):
vs = VectorSet(self.parent_node)
self.assertEqual(self.vP1 in vs, False)
def lowLine(ptsA, ptsB):
""" Lower part of bresenham algorithm
:param ptsA:
:param ptsB:
:return:
"""
pts = [ptsA]
x1, y1 = ptsA.x, ptsA.y
x2, y2 = ptsB.x, ptsB.y
dx = x2 - x1
dy = y2 - y1
yi = 1
if dy < 0:
yi = -1
dy = -dy
error = (2 * dy) - dx
y = y1
for x in range(x1, x2):
pts.append(Vector(x, y))
if error > 0:
y += yi
error += 2 * (dy - dx)
else:
error += 2 * dy
pts.append(ptsB)
return pts
def highLine(ptsA, ptsB):
""" Upper part of bresenham algorithm
:param ptsA:
:param ptsB:
:return:
"""
pts = [ptsA]
x1, y1 = ptsA.x, ptsA.y
x2, y2 = ptsB.x, ptsB.y
dx = x2 - x1
dy = y2 - y1
xi = 1
if dx < 0:
xi = -1
dx = -dx
error = (2 * dx) - dy
x = x1
for y in range(y1, y2):
pts.append(Vector(x, y))
if error > 0:
x += xi
error += 2 * (dx - dy)
else:
error += 2 * dx
pts.append(ptsB)
return pts
def pos2coord(idx, width):
""" Convert position to coordinates
:param idx (int): position to convert
:param width: world's width
:return: (x, y) coordinates
"""
return Vector(idx % width, idx // width)
def Reset(self, pos):
""" Reset the agent on a given position
:param pos (Vector): Vector representing the initial position of the agent
:return:
"""
self._pos = pos
self._speed = Vector(0, 0)
self._path = []
def playAction(self, action):
""" Compute the next state and rewards for an agent for a given action
:param action (int): action to perform
:return: ((int) new state, (float) reward, (bool) is new state terminal)
"""
self._counter += 1
new_pos, new_speed = self.car.Move(action)
end = False
out, pts = self.outOfTrack(self.car.Pos, new_pos)
if out:
r = -100
new_pos = pts
new_speed = Vector(0, 0)
elif self.crossedLine(self.car.Pos, new_pos, self._checkpointLine1):
if not self._checkpointCrossed[0]:
r = 20
self._checkpointCrossed[0] = True
else:
r = -20
elif self.crossedLine(self.car.Pos, new_pos, self._checkpointLine2):
if self._checkpointCrossed[0] and not self._checkpointCrossed[1]:
r = 20
self._checkpointCrossed[1] = True
else:
r = -20
elif self.crossedLine(self.car.Pos, new_pos, self._finishLine):
if self._checkpointCrossed[0] and self._checkpointCrossed[1]:
r = 100
end = True
else:
r = -100
elif new_pos in self.car._path:
r = -100
else:
r = -1
if self._counter > 200:
r = -1000
end = True
if not end:
self.car.ComputeMove(new_pos, new_speed)
return coord2pos(new_pos, self.width), r, end
def generate_plottable_points_between_twopoints(cls, point1: List[Point],
point2: List[Point]):
vec = Vector.create_vector_from_2points(point1, point2)
distance_between_point1_2 = Point.euclidean_distance(point1, point2)
max_distance_between2points = 1
min_distance_between2points = max_distance_between2points * .5
unit = vec.UnitVector
lst_results = []
delta = distance_between_point1_2 / 10 #some random value
last_point = point1
last_t = 0
max_t = distance_between_point1_2
while (True):
new_t = last_t + delta
if (new_t > max_t):
break
next_point = Point(point1.X + unit.X * new_t,
point1.Y + unit.Y * new_t)
distance = Point.euclidean_distance(last_point, next_point)
if (distance < max_distance_between2points
and distance > min_distance_between2points):
#just right
last_t = new_t
lst_results.append(next_point)
last_point = next_point
continue
elif (distance <= min_distance_between2points):
#too close
delta = delta * 1.5
continue
elif (distance >= max_distance_between2points):
#too far
delta = delta * .5
continue
else:
continue
return lst_results
def test_constructor(self):
vector = Vector((self.n1, self.n2), 0)
self.assertEqual(vector.endpoints_nodes, (self.n1, self.n2),
"failed constructor node set")
self.assertEqual(vector.weight, 0, "failed constructor weight")
def test_make_vector(self):
v1 = Vector.make_vector(self.n1, self.n2, 0)
v2 = Vector((self.n1, self.n2), 0)
self.assertEqual(v1, v2)
def test_not_equal_direction(self):
v1 = Vector((self.n1, self.n2), 0)
v2 = Vector((self.n2, self.n1), 0)
self.assertNotEqual(v1, v2, "failed direction not equal")
def test_not_equal_weight(self):
v1 = Vector((self.n1, self.n2), 0)
v2 = Vector((self.n1, self.n2), 4)
self.assertNotEqual(v1, v2, "failed weight not equal")
def test_vector_construction(self):
v=Vector(100,200)
self.assertEquals(v.X,100)
self.assertEquals(v.Y,200)
def test_create_vector(self):
p1=Point(1,1)
p2=Point(2,2)
v=Vector.create_vector_from_2points(p1,p2)
self.assertEquals(v.X,1)
self.assertEquals(v.Y,1)
def test_vector_length(self):
v=Vector(3,4)
self.assertEquals(v.Length,5)
def distance(self):
if (self._distance != -1):
return self._distance
vec = Vector.create_vector_from_2points(self.point1, self.point2)
self._distance = vec.Length
return self._distance
def __init__(self, initPos, power=1):
self._speed = Vector(0, 0)
self._acceleration = Vector(0, 0)
self._pos = initPos
self._path = []
self._power = power
self._acceleration = [
Vector(-1, -1), Vector(0, -1), Vector(1, -1),
Vector(-1, 0), Vector(0, 0), Vector(1, 0),
Vector(-1, 1), Vector(0, 1), Vector(1, 1),
]
def test_equal(self):
v1 = Vector((self.n1, self.n2), 0)
v2 = Vector((self.n1, self.n2), 0)
self.assertEqual(v1, v2, "failed equality")
import pyglet
from pyglet import clock, shapes
from pyglet.window import key
from src.Track import Track
from src.Vector import Vector
from src.qlearning import QLearning
track = Track('../tracks/track05.png',
startPos=Vector(26, 3),
finishA=Vector(25, 1),
finishB=Vector(25, 5),
checkPointC=Vector(20, 44),
checkPointD=Vector(20, 48),
checkPointA=Vector(89, 8),
checkPointB=Vector(99, 8))
ql = QLearning(track, alpha=0.1, gamma=0.95)
# Window
tile_size = 10
window = pyglet.window.Window(width=track.width * tile_size,
height=(track.height * tile_size) + 200)
track_img = pyglet.image.load('../tracks/track05.png')
sprite = pyglet.sprite.Sprite(img=track_img, x=0, y=0)
sprite.scale = 10
f1_img = pyglet.image.load('f1.png')
sprite_f1 = pyglet.sprite.Sprite(img=f1_img, x=0, y=0)
sprite_f1.scale = 0.01
def __make_path(self, neighbors):
vectors_to_neighbors = set()
for neighbor in neighbors:
vectors_to_neighbors.add(Vector.make_vector(self, neighbor, 1))
return vectors_to_neighbors
