def test_dot(self):
v = Vector2(1, 0)
u = Vector2(0, 1)
w = Vector2(2, 1)
self.assertTrue(v.dot(u) == 0)
self.assertTrue(u.dot(v) == 0)
self.assertTrue(v.dot(w) == 2)
def __init__(self,
position: Vector2 = Vector2(0, 0),
orientation: float = 90.0,
color: Tuple[float, float, float] = (0, 0, 0),
mesh: List[Vector2] = (Vector2(1.25, 2), Vector2(-1.25, 2),
Vector2(-1.25, -2), Vector2(1.25, -2)),
velocity: float = 0.0,
max_velocity: float = 10.0,
acceleration: float = 0.0,
max_acceleration: float = 1.0):
super(Vehicle, self).__init__(position, orientation, color, velocity, max_velocity,
acceleration, max_acceleration, mesh)
self.__target = None # type: Vector2
self.trajectory = [] # type: [Vector2]
self.active = False
self.length = self.mesh[0][1] - self.mesh[2][1] # TODO: length and width specifically for rectangular vehicles!
self.width = self.mesh[0][0] - self.mesh[1][0]
self.driver = IntelligentDriver()
self.turn_signal = Vehicle.TURN_SIGNAL_NONE
self.events = []
self.lane = None # type: Lane
self.change_permit = False
self.respawn = True
self.blocker = None
self.logger = logging.getLogger('simulation.agent.Vehicle')
def handle_input(self) -> None:
if not self.interactive:
return
k = cv2.waitKey(1)
if k == 27 or k == 1048603: # wait for ESC key to exit
self.quit = True
cv2.destroyAllWindows()
return
if k == 119 or k == 1048695: # W
self.camera.move(Vector2(0, 10.0) / self.camera.zoom)
if k == 115 or k == 1048691: # S
self.camera.move(Vector2(0.0, -10.0) / self.camera.zoom)
if k == 100 or k == 1048676: # D
self.camera.move(Vector2(10.0, 0.0) / self.camera.zoom)
if k == 97 or k == 1048673: # A
self.camera.move(Vector2(-10.0, 0) / self.camera.zoom)
if k == 113 or k == 1048689: # Q
self.camera.orientation -= 5
if k == 101 or k == 1048677: # E
self.camera.orientation += 5
if k == 114 or k == 1048690: # R
self.camera.zoom *= 1.1
if k == 102 or k == 1048678: # F
self.camera.zoom /= 1.1
if k == 109 or k == 1048685: # M
self.mode = Renderer.Mode(
(self.mode.value + 1) % len(Renderer.Mode))
if k == 112 or k == 1048688: # P
self.pause = not self.pause
def test_distance_squared(self):
v = Vector2(1, 0)
u = Vector2(0, 1)
w = Vector2(-1, 0)
eps = 0.001
self.assertTrue(abs(v.distance_squared(u) - 2) < eps)
self.assertTrue(abs(u.distance_squared(v) - 2) < eps)
self.assertTrue(abs(v.distance_squared(w) - 4) < eps)
def test_distance(self):
v = Vector2(1, 0)
u = Vector2(0, 1)
w = Vector2(-1, 0)
eps = 0.001
self.assertTrue(abs(v.distance(u) - math.sqrt(2)) < eps)
self.assertTrue(abs(u.distance(v) - math.sqrt(2)) < eps)
self.assertTrue(abs(v.distance(w) - 2) < eps)
def test_rotate(self):
v = Vector2(1, 0)
u = Vector2(0, 1)
w = Vector2(1 / math.sqrt(2), 1 / math.sqrt(2))
eps = 0.001
v.rotate(-90)
self.assertTrue(abs(v.x - u.x) < eps and abs(v.y - u.y) < eps)
u.rotate(45)
self.assertTrue(abs(w.x - u.x) < eps and abs(w.y - u.y) < eps)
def update_vehicle(self, delta_time: float) -> None:
self.velocity += delta_time * self.acceleration
heading = Vector2(0, 1)
heading.rotate(self.orientation)
self.position += delta_time * self.velocity * heading
direction = self.position - self.target
direction.normalize()
angle = Vector2(0, 1).distance_angular_signed(direction)
# check if agent passed its target
if abs(angle - self.orientation) < Lane.EPSILON:
self.lane.fix_vehicle_position(self)
def __init__(self, position: Vector2=Vector2(0, 0)):
super(Obstacle, self).__init__(position,
orientation=90,
color=(0, 0, 0),
mesh=[Vector2(0.5, 0.5), Vector2(-0.5, 0.5),
Vector2(-0.5, -0.5), Vector2(0.5, -0.5)],
velocity=0,
max_velocity=0,
acceleration=0,
max_acceleration=0)
self.driver = DummyDriver()
def __init__(self,
width: int = 512,
height: int = 256,
zoom: float = 2.0,
target: SimulationObject = None):
super(Camera2D, self).__init__()
self.__viewport = Vector2(width, height) # type: Vector2
self.__offset = Vector2(self.__viewport.x / 2,
self.__viewport.y / 2) # type: Vector2
self.zoom = zoom # type: float
self.target = target # type: SimulationObject
self.distance_threshold = 0.05 # type: float
def move(self, distance: Vector2) -> None:
"""Move the camera a given distance in the camera's perspective"""
heading = Vector2(0, 1)
heading.rotate(self.orientation)
normal = heading.copy()
normal.rotate(90)
self.position += heading * distance.y + normal * distance.x
def __init__(self, camera: Camera2D):
self.camera = camera # type: Camera2D
self.camera.viewport = Vector2(cr.CONFIG.getint('renderer', 'width'),
cr.CONFIG.getint('renderer', 'height'))
self.camera.zoom = cr.CONFIG.getfloat('renderer',
'zoom') # type: float
self.interactive = cr.CONFIG.getboolean('renderer',
'interactive') # type: bool
self.mode = Renderer.Mode.SURFACE # type Enum
self.background_brightness = 1.0 # type: int
def mouse_callback(self, event: int, x: int, y: int, flags: int,
param: int) -> None:
window_position = Vector2(x, y)
world_position = self.camera.apply_inverse_view_transform(
window_position)
if event == cv2.EVENT_LBUTTONDBLCLK:
print('(' + str(world_position.x) + ', ' + str(world_position.y) +
')')
if event == cv2.EVENT_RBUTTONDOWN:
self.mouse_drag = True
self.ix, self.iy = x, y
self.last_position = self.camera.position.copy()
elif event == cv2.EVENT_RBUTTONUP:
self.mouse_drag = False
elif event == cv2.EVENT_MOUSEMOVE and self.mouse_drag:
movement = Vector2(x, y) - Vector2(self.ix, self.iy)
self.camera.position = self.last_position.copy()
self.camera.position += Vector2(-movement.x,
movement.y) / self.camera.zoom
def __init__(self, path, num_lanes):
super(Road, self).__init__(position=Vector2(),
orientation=0,
color=(0.5, 0.5, 0.5),
mesh=[])
self.lanes = [] # type: [Lane]
self.create_lanes(path, num_lanes)
for node in self.lanes[0].right:
self.mesh.append(node)
for node in reversed(self.lanes[-1].left):
self.mesh.append(node)
def move_camera(self) -> None:
if self.step % self.writer.write_sample_size == 0:
location = self.rng.randint(0, len(self.locations) - 1)
self.camera.position = self.locations[location][0].copy()
self.camera.orientation = self.locations[location][1]
if self.jitter:
r = self.rng.uniform(-self.jitter_size[2], self.jitter_size[2])
f = self.rng.randint(0, 1)
s = self.rng.uniform(-self.jitter_size[1], self.jitter_size[1])
t = self.rng.uniform(-self.jitter_size[0], self.jitter_size[0])
self.camera.position += Vector2(t, 1 + s)
self.camera.orientation += r + f * 180.0
def __init__(self,
position: Vector2 = Vector2(0, 0),
orientation: float = 0.0,
color: Tuple[float, float, float] = (0.0, 0.0, 0.0),
velocity: float = 0.0,
max_velocity: float = 0.0,
acceleration: float = 0.0,
max_acceleration: float = 0.0,
mesh: List[Vector2] = None):
if mesh is None:
mesh = [
Vector2(0.5, 0.5),
Vector2(-0.5, 0.5),
Vector2(-0.5, -0.5),
Vector2(0.5, -0.5)
]
self.position = Vector2(position.x, position.y) # type: Vector2
self.orientation = orientation # type: float
self.color = color # type: Tuple[float, float, float]
self.mesh = mesh # type: List[Vector2]
self.active = True # type: bool
self.__acceleration = acceleration # type: float
self.max_acceleration = max_acceleration # type: float
self.__velocity = velocity # type: float
self.max_velocity = max_velocity # type: float
self.id = SimulationObject.ID # type: int
SimulationObject.ID += 1