def getStaticScenario(testName):
beamng = BeamNGpy('localhost', 64256, home=getBeamngDirectory()
) # This is the host & port used to communicate over
staticScenario = Scenario('smallgrid', str(testName))
testVehicle = Vehicle('Test_Vehicule',
model=SelectCar(),
licence='LIFLAB',
colour='Blue')
# Create an Electrics sensor and attach it to the vehicle
electrics = Electrics()
testVehicle.attach_sensor('electrics', electrics)
# Create a Damage sensor and attach it to the vehicle if module is selected
damage = Damage()
testVehicle.attach_sensor('damage', damage)
# Create a Gforce sensor and attach it to the vehicle if module is selected
gForce = GForces()
testVehicle.attach_sensor('GForces', gForce)
staticScenario.add_vehicle(testVehicle, (0, 0, 0), (0, 0, -90))
scenarioDict = {
'beamng': beamng,
'scenario': staticScenario,
'vehicule': testVehicle
}
return scenarioDict
def main(beamng, scenario_name):
# Find a scenario in the smallgrid level called 'Case4'
level = 'smallgrid'
scenario = Scenario(level, scenario_name)
# Update the scenario instance with its path
scenario.find(beamng)
bng = beamng.open(launch=True)
bng.hide_hud()
bng.set_deterministic() # Set simulator to be deterministic mode
# Load and start the scenario
bng.load_scenario(scenario)
# Gets vehicles placed in the scenario
vehicle_bng = 'BeamNGVehicle'
vehicles = create_vehicle(bng.find_objects_class(vehicle_bng))
# bng.set_steps_per_second(10)
for vehicle in vehicles:
bng.connect_vehicle(vehicle)
assert vehicle.skt
bng.step(75, wait=True)
bng.start_scenario()
for _ in range(64):
bng.step(30)
s1 = bng.poll_sensors(vehicles[0])
s2 = bng.poll_sensors(vehicles[1])
print(s1)
print(s2)
print('------')
def setup_BeamNG(self):
# Create a scenario in test map
self.scenario = Scenario('cruise-control', 'example')
# Create an ETK800 with the licence plate 'PID'
self.vehicle = Vehicle('ACC', model='etk800', licence='ACC')
electrics = Electrics()
self.vehicle.attach_sensor('electrics',
electrics) # Cars electric system
# Add it to our scenario at this position and rotation
self.scenario.add_vehicle(self.vehicle, pos=ACC_CAR_POS, rot=(0, 0, 0))
self.vehicle2 = Vehicle('FRONT', model='etk800', licence='FRONT')
self.vehicle2.attach_sensor('electrics',
electrics) # Cars electric system
self.scenario.add_vehicle(self.vehicle2,
pos=FRONT_CAR_POS,
rot=(0, 0, 180))
# Place files defining our scenario for the simulator to read
self.scenario.make(self.bng)
# Launch BeamNG.research
self.bng.open()
# Load and start our scenario
self.bng.load_scenario(self.scenario)
self.bng.start_scenario()
def bring_up(self):
if self.reuse_beamng:
# This assumes BeamNG is already running
self.beamng.open(launch=False)
else:
self.beamng.open(launch=True)
# After 1.18 to make a scenario one needs a running instance of BeamNG
self.scenario = Scenario('tig', 'tigscenario')
if self.vehicle:
self.scenario.add_vehicle(self.vehicle,
pos=self.vehicle_start_pose.pos,
rot=self.vehicle_start_pose.rot)
if self.camera:
self.scenario.add_camera(self.camera.camera, self.camera.name)
self.scenario.make(self.beamng)
self.beamng.set_deterministic()
self.beamng.load_scenario(self.scenario)
self.beamng.start_scenario()
# Pause the simulator only after loading and starting the scenario
self.beamng.pause()
def _init_beamNG(self) -> None:
"""
Initialize beamNG:
Create the scenario, vehicle, sensors, and load everything
"""
self.scenario = Scenario(self.OPTIONS['scenario_map'],
self.OPTIONS['scenario_name'],
description=self.OPTIONS['scenario_desc'])
self.vehicle = Vehicle(self.OPTIONS['vehicle_name'],
model=self.OPTIONS['vehicle_model'],
license=self.OPTIONS['vehicle_license'])
self.lidar_sensor = Lidar(max_dist=180, vres=24, vangle=25)
self.vehicle.attach_sensor('lidar', self.lidar_sensor)
self.front_camera = Camera(self.OPTIONS['f_cam_pos'],
self.OPTIONS['f_cam_dir'],
self.OPTIONS['f_cam_fov'],
self.OPTIONS['f_cam_res'],
colour=True,
annotation=True)
self.vehicle.attach_sensor('front_camera', self.front_camera)
self.scenario.add_vehicle(self.vehicle, self.OPTIONS['vehicle_pos'],
self.OPTIONS['vehicle_rot'],
self.OPTIONS['vehicle_rot_quat'])
self.scenario.make(self.beamng)
self.beamng.load_scenario(self.scenario)
def test_find_scenario(beamng):
with beamng as bng:
scenario = Scenario('west_coast_usa', 'derby_asphalt')
scenario.find(bng)
assert scenario.get_info_path() is not None
bng.load_scenario(scenario)
assert bng.get_scenario_name(
) == 'scenarios.west_coast_usa.derby_asphalt.title'
def _start_simulation(self,
test_case: TestCase) -> Tuple[Scenario, ExtThread]:
from threading import Thread
from config import BEAMNG_LEVEL_NAME
from beamngpy.beamngcommon import BNGValueError
Simulation._start_simulation.lock.acquire()
while not Simulation._is_port_available(
Simulation._start_simulation.port):
Simulation._start_simulation.port += 200 # Make sure to not interfere with previously started simulations
self._bng_instance = DBBeamNGpy('localhost',
Simulation._start_simulation.port)
authors = ", ".join(test_case.authors)
bng_scenario = Scenario(BEAMNG_LEVEL_NAME,
self._sim_name,
authors=authors)
test_case.scenario.add_all(bng_scenario)
bng_scenario.make(self._bng_instance)
# Make manual changes to the scenario files
self._make_lanes_visible()
self._annotate_objects()
self._add_waypoints_to_scenario(test_case.scenario.participants)
self._enable_participant_movements(test_case.scenario.participants)
waypoints = set()
for wps in [p.movement for p in test_case.scenario.participants]:
for wp in wps:
if wp.id is not None: # FIXME Waypoints are added in wrong order
waypoints.add(wp.id)
# self._add_lap_config(waypoints)
try:
self._bng_instance.open(launch=True)
self._bng_instance.load_scenario(bng_scenario)
self._bng_instance.set_steps_per_second(test_case.stepsPerSecond)
self._bng_instance.set_deterministic()
test_case.scenario.set_time_of_day_to(self._bng_instance)
self._bng_instance.hide_hud()
self._bng_instance.start_scenario()
self._bng_instance.pause()
except OSError:
_logger.exception("The start of a BeamNG instance failed (Port: " +
str(Simulation._start_simulation.port) + ").")
except BNGValueError:
_logger.exception(
"Sending to or receiving from BeamNGpy failed and may corrupt the socket"
)
Simulation._start_simulation.lock.release()
runtime_thread = Thread(target=Simulation._run_runtime_verification,
args=(self, test_case.aiFrequency))
runtime_thread.daemon = True
runtime_thread.start()
while not runtime_thread.ident: # Wait for the Thread to get an ID
pass
return bng_scenario, ExtThread(runtime_thread.ident)
def __init__(self):
super().__init__()
# Break an episode upon user input.
thread = Thread(target=self._intervene)
thread.start()
self.step = 0
self.dist_driven = 0
self.done = False
self.last_action = (0.0, 0.0)
self.bng = BeamNGpy('localhost', 64257, home=BEAMNG_HOME)
self.scenario = Scenario('train',
'train',
authors='Vsevolod Tymofyeyev',
description='Reinforcement learning')
self.road = TrainingRoad(ASFAULT_PREFAB)
self.road.calculate_road_line()
spawn_point = self.road.spawn_point()
self.last_pos = spawn_point.pos()
self.scenario.add_road(self.road.asphalt)
self.scenario.add_road(self.road.mid_line)
self.scenario.add_road(self.road.left_line)
self.scenario.add_road(self.road.right_line)
self.vehicle = Vehicle('ego_vehicle',
model='etk800',
licence='RL FTW',
color='Red')
front_camera = Camera(pos=(0, 1.4, 1.8),
direction=(0, 1, -0.23),
fov=FOV,
resolution=(CAMERA_WIDTH, CAMERA_HEIGHT),
colour=True,
depth=False,
annotation=False)
self.vehicle.attach_sensor("front_camera", front_camera)
self.scenario.add_vehicle(self.vehicle,
pos=spawn_point.pos(),
rot=spawn_point.rot())
# At this point, BeamNG creates a prefab file which contains the specified roads.
self.scenario.make(self.bng)
prefab_path = self.scenario.get_prefab_path()
# Update the road definitions in the prefab.
update_prefab(prefab_path)
self.bng.open()
self.bng.set_deterministic()
self.bng.set_steps_per_second(SPS)
self.bng.load_scenario(self.scenario)
self.bng.start_scenario()
# self.bng.hide_hud()
self.bng.pause()
def __init__(self,
bng_home,
output,
config,
poolsize=2,
smallgrid=False,
sim_mtx=None,
similarity=0.5,
random_select=False,
single=False):
self.bng_home = bng_home
self.output = output
self.config = config
self.smallgrid = smallgrid
self.single = single
self.impactgen_mats = None
if smallgrid:
mats = materialmngr.get_impactgen_materials(bng_home)
self.impactgen_mats = sorted(list(mats))
self.poolsize = poolsize
self.similarity = similarity
self.sim_mtx = sim_mtx
self.random_select = random_select
self.pole_space = None
self.t_bone_space = None
self.linear_space = None
self.nocrash_space = None
self.post_space = None
self.total_possibilities = 0
self.bng = BeamNGpy('localhost', 64256, home=bng_home)
self.scenario = None
scenario_props = ImpactGenerator.wca
if smallgrid:
scenario_props = ImpactGenerator.smallgrid
self.vehicle_a = Vehicle('vehicle_a', model='etk800')
self.vehicle_b = Vehicle('vehicle_b', model='etk800')
self.scenario = Scenario(scenario_props['level'], 'impactgen')
self.scenario.add_vehicle(self.vehicle_a,
pos=scenario_props['a_spawn'],
rot=(0, 0, 0))
self.scenario.add_vehicle(self.vehicle_b,
pos=scenario_props['b_spawn'],
rot=(0, 0, 0))
self.vehicle_a_parts = defaultdict(set)
self.vehicle_a_config = None
self.vehicle_b_config = None
def test_find_scenario(beamng):
with beamng as bng:
scenario = Scenario('west_coast_usa', 'derby_asphalt')
assert scenario.find(bng) is not None
bng.load_scenario(scenario)
assert 'derby' in bng.get_scenario_name().lower()
try:
bng.start_scenario()
assert True
except socket.timeout:
assert False
def execute_scenario(self, bng):
scenario = Scenario(self.level, self.scenario)
# Update the scenario instance with its path
scenario.find(bng)
# Configures BeamNG client
bng.open(launch=True)
bng.hide_hud()
bng.set_deterministic() # Set simulator to be deterministic mode
# Load and start the scenario
bng.load_scenario(scenario)
# Gets vehicles placed in the scenario
vehicle_bng = 'BeamNGVehicle'
self.create_vehicle(bng.find_objects_class(vehicle_bng))
# bng.set_steps_per_second(10)
for car in self.cars:
vehicle = car.vehicle
bng.connect_vehicle(vehicle)
assert vehicle.skt
# Wait for 50 steps before start
waiting_steps = 50
bng.step(waiting_steps, wait=True)
bng.start_scenario() # Start scenario
accident_log = {}
for _ in range(self.timeout):
empty = not bool(accident_log)
if empty:
# Collects sensor data every 30 steps
bng.step(30)
for car in self.cars:
vehicle = car.vehicle
sensor = bng.poll_sensors(vehicle)['damage']
if (sensor['damage'] != 0): # Crash detected
print("Crash detected!")
self.isCrash = True
accident_log.update(
{vehicle.vid: sensor['part_damage']})
car.damage = sensor['part_damage']
else:
self.write_log(accident_log) # Write log file
waiting_steps = 175
bng.step(waiting_steps, wait=True)
print("Within time!")
break
# Timeout
if not self.isCrash:
print("Timed out!")
self.close_scenario(bng)
def __init__(self):
self.collected_data = {"image_name": [], "steering": []}
self.scenario = Scenario(config.get("data_collecting.scenario_level"),
config.get("data_collecting.scenario_name"))
self.vehicle = Vehicle(
'ego_vehicle',
model=config.get("data_collecting.vehicle_model"),
licence='PYTHON')
self.bng = BeamNGpy(config.get("beamNG.host"),
int(config.get("beamNG.port")),
home=config.get("beamNG.home"))
def main():
beamng = BeamNGpy('localhost', 64256)
scenario = Scenario('GridMap', 'road_test')
road_a = Road('track_editor_C_center', looped=True)
nodes = [
(-25, 300, 0, 5),
(25, 300, 0, 6),
(25, 350, 0, 4),
(-25, 350, 0, 5),
]
road_a.nodes.extend(nodes)
scenario.add_road(road_a)
road_b = Road('track_editor_C_center')
nodes = [
(0, 325, 0, 5),
(50, 375, 0, 5),
]
road_b.nodes.extend(nodes)
scenario.add_road(road_b)
scenario.make(beamng)
bng = beamng.open(launch=True)
try:
bng.load_scenario(scenario)
bng.start_scenario()
input('Press enter when done...')
finally:
bng.close()
def test_camera_control(beamng):
with beamng as bng:
scenario = Scenario('smallgrid', 'camera_control_test')
ego = Vehicle('ego', model='etk800')
other = Vehicle('other', model='etk800')
scenario.add_vehicle(ego, pos=(0, 0, 0))
scenario.add_vehicle(other, pos=(5, 5, 0))
scenario.make(bng)
bng.load_scenario(scenario)
bng.start_scenario()
camera_configs = bng.get_player_camera_modes(ego.vid)
for camera in camera_configs.keys():
bng.set_player_camera_mode(ego.vid, camera, {})
time.sleep(5)
current_camera = bng.get_player_camera_modes(ego.vid)
assert current_camera[camera]['focused']
time.sleep(10)
assert 'orbit' in camera_configs
bng.set_player_camera_mode(ego.vid, 'orbit', {'distance': 50})
time.sleep(5)
current_camera = bng.get_player_camera_modes(ego.vid)
assert current_camera['orbit']['focused']
assert abs(current_camera['orbit']['camDist'] - 50) < 0.5
def getStrangeScenario():
beamNGPAth = getBeamngDirectory()
beamng = BeamNGpy(
'localhost', 64256,
home=beamNGPAth) # This is the host & port used to communicate over
wallCrashScenario = Scenario('smallgrid', 'road_test')
wall = StaticObject(
name="Crash_Test_Wall",
pos=(10, 0, 0),
rot=(0, 0, 0),
scale=(1, 10, 1),
shape='/levels/smallgrid/art/shapes/misc/gm_alpha_barrier.dae')
testRoad = Road('track_editor_A_center', rid='Test_Road')
roadNode = [(-10, 0, 0, 7), (20, 0, 62)]
testRoad.nodes.extend(roadNode)
testVehicle = Vehicle('Test_Vehicule',
model='etkc',
licence='LIFLAB',
colour='Blue')
wallCrashScenario.add_road(testRoad)
wallCrashScenario.add_object(wall)
wallCrashScenario.add_vehicle(testVehicle,
pos=(0, 0, 0),
rot=(0, 180, -90))
scenarioDict = {
'beamng': beamng,
'scenario': wallCrashScenario,
'vehicule': testVehicle
}
return scenarioDict
def test_ultrasonic(beamng):
with beamng as bng:
scenario = Scenario('smallgrid', 'ultrasonic_test')
cube_dist = 4
cube = ProceduralCube(name='cube',
pos=(0, -cube_dist, 5),
rot=None,
rot_quat=(0, 0, 0, 1),
size=(1, 20, 10))
scenario.add_procedural_mesh(cube)
pos = (0, 1, 2)
rot = (0, 1, 0)
ultrasonic = Ultrasonic(pos, rot)
vehicle = Vehicle('test', model='pickup')
vehicle.attach_sensor('ultrasonic', ultrasonic)
scenario.add_vehicle(vehicle, pos=(0, 0, 0), rot_quat=(0, 0, 0, 1))
scenario.make(beamng)
bng.load_scenario(scenario)
bng.start_scenario()
vehicle.poll_sensors()
assert 0 < vehicle.sensors['ultrasonic'].data['distance'] < cube_dist
def main():
beamng = BeamNGpy('localhost', 64256, home='F:\Softwares\BeamNG_Research_SVN')
scenario = Scenario('GridMap', 'road_test')
road_a = Road('custom_track_center', looped=False)
nodes = [
(0, 0, 0, 4),
(0, 400, 0, 4),
]
road_a.nodes.extend(nodes)
scenario.add_road(road_a)
vehicle = Vehicle('ego', model='etk800', licence='PYTHON', colour='Black')
scenario.add_vehicle(vehicle, pos = ( 0, 0, 0.163609) , rot=(0,0,180)) # 0.163609 ,
scenario.make(beamng)
script = list()
node0 = {
'x': 0,
'y': 2,
'z': 0.163609,
't': 0.01,
}
node1 = {
'x': 0,
'y': 3,
'z': 0.163609,
't': 0.01,
}
node2 = {
'x': 0,
'y': 350,
'z': 0.163609,
't': 15,
}
node3 = {
'x': 0,
'y': 400,
'z': 0.163609,
't': 5,
}
script.append(node0)
script.append(node1)
script.append(node2)
script.append(node3)
bng = beamng.open(launch=True)
try:
bng.load_scenario(scenario)
bng.start_scenario()
vehicle.ai_set_script(script)
input('Press enter when done...')
finally:
bng.close()
def main():
beamng = BeamNGpy('localhost',
64256,
home='C:/Users/merie/Documents/BeamNG.research.v1.7.0.0')
scenario = Scenario('GridMap', 'road_test')
road_a = Road('track_editor_C_center', rid='circle_road', looped=True)
nodes = [
(-25, 300, 0, 5),
(25, 300, 0, 6),
(25, 350, 0, 4),
(-25, 350, 0, 5),
]
road_a.nodes.extend(nodes)
scenario.add_road(road_a)
road_b = Road('track_editor_C_center', rid='center_road')
nodes = [
(0, 325, 0, 5),
(50, 375, 0, 5),
]
road_b.nodes.extend(nodes)
scenario.add_road(road_b)
scenario.make(beamng)
bng = beamng.open(launch=True)
try:
bng.load_scenario(scenario)
bng.start_scenario()
input('Press enter when done...')
finally:
bng.close()
def bring_up(self):
self.scenario = Scenario('tig', 'tigscenario')
if self.vehicle:
self.scenario.add_vehicle(self.vehicle, pos=self.vehicle_start_pose.pos, rot=self.vehicle_start_pose.rot)
if self.camera:
self.scenario.add_camera(self.camera.camera, self.camera.name)
self.scenario.make(self.beamng)
if not self.beamng.server:
self.beamng.open()
self.beamng.pause()
self.beamng.set_deterministic()
self.beamng.load_scenario(self.scenario)
self.beamng.start_scenario()
def add_participants_to_scenario(self, scenario: Scenario) -> None:
from dbtypes.beamng import DBVehicle
for participant in self.participants:
# FIXME Adjust color
vehicle = DBVehicle(participant.id,
model=participant.model,
color="White",
licence=participant.id)
for request in participant.ai_requests:
vehicle.apply_request(request)
initial_state = participant.initial_state
# NOTE Participants use degrees for rotation
scenario.add_vehicle(vehicle,
pos=(initial_state.position[0],
initial_state.position[1], 0),
rot=(0, 0, -initial_state.orientation - 90))
def _init_beamNG(self) -> None:
self.scenario = Scenario(self.scenario_map,
self.scenario_name,
description=self.scenario_desc)
self.vehicle = Vehicle(self.vehicle_name,
model=self.vehicle_model,
license=self.vehicle_license)
self.lidar_sensor = Lidar()
self.vehicle.attach_sensor('lidar', self.lidar_sensor)
self.scenario.add_vehicle(self.vehicle, self.vehicle_pos,
self.vehicle_rot, self.vehicle_rot_quat)
self.scenario.make(self.beamng)
self.beamng.load_scenario(self.scenario)
def test_vehicle_spawn(beamng):
scenario = Scenario('smallgrid', 'spawn_test')
vehicle = Vehicle('irrelevant', model='pickup')
scenario.add_vehicle(vehicle, pos=(0, 0, 0), rot=(0, 0, 0))
scenario.make(beamng)
with beamng as bng:
bng.load_scenario(scenario)
bng.start_scenario()
other = Vehicle('relevant', model='etk800')
scenario.add_vehicle(other, pos=(10, 10, 0), rot=(0, 0, 0))
other.update_vehicle()
assert 'pos' in other.state
bng.step(120)
scenario.remove_vehicle(other)
bng.step(600)
assert other.state is None
def setup_beamng(traffic=2):
global sp, beamng_home, beamng_user
setup_logging()
beamng = BeamNGpy('localhost', 64256, home=beamng_home, user=beamng_user)
scenario = Scenario(
'west_coast_usa',
'lidar_tour',
description=
'Tour through highway with variable traffic vehicles gathering '
'Lidar data')
# setup vehicle
vehicle = Vehicle('ego_vehicle',
model='etk800',
licence='LIDAR',
color='Red')
vehicle = setup_sensors(vehicle)
# setup vehicle poses
lane = random.choice([1, 2, 3, 4])
ego_sp = spawn_point(sp, lane)
ego_pos = ego_sp['pos']
ego_rot_quat = ego_sp['rot_quat']
lane = ego_sp['lane']
# add vehicles to scenario
# print("adding vehicle to scenario...")
scenario.add_vehicle(vehicle, pos=ego_pos, rot=None, rot_quat=ego_rot_quat)
tvs = traffic_vehicles(traffic)
ps = generate_vehicle_positions(ego_pos, ego_rot_quat, lane, tvs)
for i in range(len(tvs)):
print("adding vehicle {}...".format(i))
scenario.add_vehicle(tvs[i], pos=ps[i], rot_quat=ego_rot_quat)
print("making scenario...")
scenario.make(beamng)
print("opening beamNG...")
bng = beamng.open(launch=True)
st = time.time()
print("loading scenario...")
bng.load_scenario(scenario)
bng.set_steps_per_second(60)
bng.set_deterministic()
#print("Bounding box: {}".format(vehicle.get_bbox()))
bng.hide_hud()
print("starting scenario...")
bng.start_scenario()
vehicle.ai_set_mode('traffic')
#"DecalRoad31765_8"
vehicle.ai_drive_in_lane(False)
vehicle.ai_set_aggression(2.0)
bng.start_traffic(tvs)
bng.switch_vehicle(vehicle)
bng.pause()
return vehicle, bng
def test_vehicle_spawn(beamng):
with beamng as bng:
scenario = Scenario('smallgrid', 'spawn_test')
vehicle = Vehicle('irrelevant', model='pickup')
scenario.add_vehicle(vehicle, pos=(0, 0, 0), rot=(0, 0, 0))
scenario.make(beamng)
bng.load_scenario(scenario)
bng.start_scenario()
other = Vehicle('relevant', model='etk800')
scenario.add_vehicle(other, pos=(10, 10, 0), rot=(0, 0, 0))
other.poll_sensors()
assert other.sensors['state'].connected
assert 'pos' in other.sensors['state'].data
bng.step(120, wait=True)
scenario.remove_vehicle(other)
bng.step(600, wait=True)
assert not other.sensors['state'].connected
def test_new_scenario(beamng):
with beamng as bng:
scenario = Scenario('smallgrid', 'test_scenario')
vehicle = Vehicle('test_car', model='etk800')
scenario.add_vehicle(vehicle, pos=(0, 0, 0), rot=(0, 0, 0))
scenario.make(bng)
bng.load_scenario(scenario)
assert bng.get_scenario_name() == 'test_scenario'
scenario.delete(beamng)
with beamng as bng:
with pytest.raises(BNGValueError):
bng.load_scenario(scenario)
def getSquareRoadScenario():
beamng = BeamNGpy('localhost', 64256, home=getBeamngDirectory()
) # This is the host & port used to communicate over
squareRoadScenario = Scenario('smallgrid', 'Straight_Foward_Test')
testRoad = Road('track_editor_C_center', rid='Test_Road', looped=True)
roadNode = [(0, 0, 0, 7), (250, 0, 0, 7), (250, 250, 0, 7), (0, 250, 0, 7)]
testRoad.nodes.extend(roadNode)
testVehicle = Vehicle('Test_Vehicule',
model='etkc',
licence='LIFLAB',
colour='Blue')
# Create an Electrics sensor and attach it to the vehicle
electrics = Electrics()
testVehicle.attach_sensor('electrics', electrics)
# Create a Damage sensor and attach it to the vehicle if module is selected
damage = Damage()
testVehicle.attach_sensor('damage', damage)
# Create a Gforce sensor and attach it to the vehicle if module is selected
gForce = GForces()
testVehicle.attach_sensor('GForces', gForce)
squareRoadScenario.add_road(testRoad)
squareRoadScenario.add_vehicle(testVehicle, pos=(0, 0, 0), rot=(0, 0, -90))
scenarioDict = {
'beamng': beamng,
'scenario': squareRoadScenario,
'vehicule': testVehicle
}
return scenarioDict
def test_noise(beamng):
scenario = Scenario('west_coast_usa', 'camera_test')
vehicle = Vehicle('test_car', model='etk800')
pos = (-0.3, 1, 1.0)
direction = (0, 1, 0)
fov = 120
resolution = (64, 64)
reference_camera = Camera(pos, direction, fov, resolution, colour=True)
vehicle.attach_sensor('reference_camera', reference_camera)
noise_camera = Camera(pos, direction, fov, resolution, colour=True)
noise_camera = WhiteGaussianRGBNoise(noise_camera, .5, 0)
vehicle.attach_sensor('noise_cam', noise_camera)
scenario.add_vehicle(vehicle, pos=(-717.121, 101, 118.675), rot=(0, 0, 45))
scenario.make(beamng)
with beamng as bng:
bng.load_scenario(scenario)
bng.step(120)
vehicle.poll_sensors()
noise_img = np.asarray(noise_camera.data['colour'])
reference_img = np.asarray(reference_camera.data['colour'])
# since this is based on two different renders this will always be different
assert (not (np.array_equal(noise_img, reference_img)))
def main():
random.seed(1703)
setup_logging()
beamng = BeamNGpy('localhost', 64256)
scenario = Scenario('west_coast_usa', 'lidar_demo',
description='Spanning the map with a lidar sensor')
vehicle = Vehicle('ego_vehicle', model='etk800',
licence='RED', color='Red')
lidar = Lidar(offset=(0, 0, 1.6))
vehicle.attach_sensor('lidar', lidar)
scenario.add_vehicle(vehicle, pos=(-717.121, 101, 118.675), rot=(0, 0, 45))
scenario.make(beamng)
bng = beamng.open(launch=True)
try:
bng.set_deterministic() # Set simulator to be deterministic
bng.set_steps_per_second(60) # With 60hz temporal resolution
bng.load_scenario(scenario)
bng.hide_hud()
bng.start_scenario()
vehicle.ai_set_mode('span')
print('Driving around for 60 seconds...')
sleep(60)
finally:
bng.close()
def test_gforces(beamng):
with beamng as bng:
scenario = Scenario('west_coast_usa', 'gforce_test')
vehicle = Vehicle('test_car', model='etk800')
gforces = GForces()
vehicle.attach_sensor('gforces', gforces)
scenario.add_vehicle(vehicle,
pos=(-717.121, 101, 118.675),
rot=(0, 0, 45))
scenario.make(beamng)
gx = []
gy = []
bng.load_scenario(scenario)
bng.start_scenario()
bng.step(120)
vehicle.ai_set_aggression(2)
vehicle.ai_set_mode('span')
for _ in range(64):
bng.step(30)
vehicle.poll_sensors()
gx.append(gforces.data['gx'])
gy.append(gforces.data['gy'])
assert np.var(gx) > 1 and np.var(gy) > 1
def test_noise(beamng):
with beamng as bng:
scenario = Scenario('west_coast_usa', 'camera_test')
vehicle = Vehicle('test_car', model='etk800')
pos = (-0.3, 1, 1.0)
direction = (0, 1, 0)
fov = 120
resolution = (64, 64)
cam = Camera(pos, direction, fov, resolution, colour=True, depth=True)
noise_cam = RandomImageNoise(cam)
vehicle.attach_sensor('noise_cam', noise_cam)
lidar = Lidar()
noise_lidar = RandomLIDARNoise(lidar, mean=0, var=.5)
vehicle.attach_sensor('noise_lidar', noise_lidar)
scenario.add_vehicle(vehicle,
pos=(-717.121, 101, 118.675),
rot=(0, 0, 45))
scenario.make(beamng)
bng.load_scenario(scenario)
bng.step(120)
time.sleep(20)
vehicle.poll_sensors()
reference_img = np.array(noise_cam._sensor.data['colour'])
noise_img = np.array(noise_cam.data['colour'])
assert (not (np.array_equal(noise_img, reference_img)))
ref_pc = lidar.data['points']
noise_pc = noise_lidar.data['points']
assert (not (np.array_equal(ref_pc, noise_pc)))
