def __init__(self, ID, agentType="robot", vehicleType="car", strategyFile=None):
self.ID = str(ID)
if vehicleType.lower() == "car":
self.vehicle = vehicle.Car(self)
elif vehicleType.lower() == "truck":
self.vehicle = vehicle.Truck(self)
elif vehicleType.lower() == "motorcycle":
self.vehicle = vehicle.Motorcycle(self)
elif vehicleType.lower() == "bicycle":
self.vehicle = vehicle.Bicycle(self)
else:
print(msgHeader + "Could not initialise Agent " + self.ID + " with vehicle type '" + vehicleType + "'.")
self.vehicle = vehicle.Car(self)
self.worldKnowledge = {}
self.strategy = None
if strategyFile is not None and strategyFile != "Manual": # Do not look for 'manual' strategy file
try:
self.strategy = import_file("strategy", strategyFile)
print(msgHeader + "Successfully loaded the strategy file for Agent " + self.ID + ".")
except:
print(msgHeader + "Could not load the strategy file for Agent " + self.ID + ". (Fatal)")
exit()
elif strategyFile is not None and strategyFile == "Manual": # Mark agent as a manual car
self.strategy = "Manual"
print(msgHeader + "Manual agent successfully initialised.")
self.stopped = False
def test_load_inputs_from_array(self):
car = vehicle.Car()
inputs = [[0.5, 0.25, -15], [0, 0, 0]]
car.load_inputs(in_list=inputs)
self.assertEqual(inputs, car.input_buffer)
def run(self, FSAngle, FSVelocity):
car = vehicle.Car(constants.CAR_POS_X, constants.CAR_POS_Y,
constants.CAR_ANGLE)
iteration = 0
dec = decoder.Decoder(FSAngle, FSVelocity, self.car, False)
while not self.exit:
dt = self.clock.get_time() / 1000
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.exit = True
ds, drot = dec.get_movement_params()
fuzzy_text = dec.fuzzy_text
self.car.update(dt, ds, drot)
current_pixel_color = self.draw_screen(fuzzy_text)
iteration = iteration + 1
if self.car.is_idle(iteration) or self.car.is_collided(
current_pixel_color):
break
self.clock.tick(self.ticks)
pygame.quit()
return vehicle.distance(self.car.center_position().x,
self.car.center_position().y, constants.GOAL.x,
constants.GOAL.y)
def main():
# Creates a Car Object
car = vehicle.Car('Bugatti', 'Veyron', 0, 3000000, 2)
# Creates a Truck object
truck = vehicle.Truck('Dodge', 'Power Wagon', 0, 57000, '4x4')
# Creates a SUV object
suv = vehicle.SUV('Jeep', 'Wrangler', 200000, 5000, 4)
print('Vehcile Inventory')
print('*****************')
# Display the vehicles's data
print('Make: ', car.get_make())
print('Model: ', car.get_model())
print('Mileage: ', car.get_mileage())
print('Price: ', car.get_price())
print('Doors: ', car.get_doors())
print('\n')
print('Make: ', truck.get_make())
print('Model: ', truck.get_model())
print('Mileage: ', truck.get_mileage())
print('Price: ', truck.get_price())
print('Drive Type: ', truck.get_drive_type())
print('\n')
print('Make: ', suv.get_make())
print('Model: ', suv.get_model())
print('Mileage: ', suv.get_mileage())
print('Price: ', suv.get_price())
print('Pass Cap: ', suv.get_pass_cap())
def test_update(self):
inputs = [[0.75, 0.0, -30]]
car = vehicle.Car(orientation=30, inputs=inputs)
t_s = 1
car.take_next_inputs(input_series=car.input_buffer)
car.update(timestep=t_s)
def test_take_next_inputs(self):
car = vehicle.Car()
inputs = [[-0.5, 0.15, 15]]
car.take_next_inputs(input_series=inputs)
self.assertEqual(inputs, car.input_buffer)
car.take_next_inputs(input_series=[])
self.assertEqual(0, car.st_angle_p)
def test_next_pos(self):
t_s = 1
car = vehicle.Car()
inputs = [0, 0, 0]
pos = [0, 0]
x, y = car.next_pos(pos, inputs, t_s)
self.assertEqual(x, 0)
self.assertEqual(y, 0)
def test__get_total_daily_toll_for_vehicle():
config_path = os.path.abspath(
os.path.dirname(__file__)) + "/full_test_config.json"
cfg = main._load_config(config_path)
car = vehicle.Car()
# 16 sek
passes = [
datetime.datetime(2019, 1, 23, 8, 0),
datetime.datetime(2019, 1, 23, 9, 0),
]
assert main._get_total_daily_toll_for_vehicle(cfg, car, passes) == 16
def park(self, registration_num, driver_age):
if self.num_of_occupied_slots < self.capacity:
slot_id = self.get_empty_slot()
self.slots[slot_id] = vehicle.Car(registration_num, driver_age)
self.slot_id = self.slot_id + 1
self.num_of_occupied_slots = self.num_of_occupied_slots + 1
return slot_id + 1
else:
return -1
def test__get_vehicle_and_passes_from_csv():
test_csv = config_path = os.path.abspath(
os.path.dirname(__file__)) + "/test.csv"
expected_passes = [
datetime.datetime(2019, 1, 23, 8, 0),
datetime.datetime(2019, 1, 23, 9, 0),
]
car = vehicle.Car()
v, passes = main._get_vehicle_and_passes_from_csv(test_csv)
assert car.get_type() == v.get_type()
assert passes == expected_passes
def main():
# Create an object from the Car class
# The car is a 2007 Audi with 12k miles, priced at
# 21.5k and has 4 doors.
used_car = vehicle.Car('Audi', 'A3', 12500, 21500.00, 4)
# Display the cars data
print('Make: ', used_car.get_make())
print('Model: ', used_car.get_model())
print('Mileage: ', used_car.get_mileage())
print('Price: ', used_car.get_price())
print('Doors: ', used_car.get_doors())
def __init__(self, path, closed_polygon):
pygame.init()
pygame.display.set_caption("Trained car")
self.screen = pygame.display.set_mode(
(constants.SCREEN_WIDTH, constants.SCREEN_HEIGHT), DOUBLEBUF)
self.screen.set_alpha(False)
self.left_screen = pygame.Surface(
(constants.LEFT_SCREEN_WIDTH, constants.SCREEN_HEIGHT))
self.right_screen = pygame.Surface(
(constants.RIGHT_SCREEN_WIDTH, constants.SCREEN_HEIGHT))
self.font = pygame.font.SysFont('Times New Roman', constants.FONT_SIZE)
self.clock = pygame.time.Clock()
self.ticks = 60
self.exit = False
self.car = vehicle.Car(constants.CAR_POS_X, constants.CAR_POS_Y,
constants.CAR_ANGLE)
self.path = path
self.closed_polygon = closed_polygon
def evaluate(FSAngle, FSVelocity, road_matrix, memory):
"""
Runs a single simulation, movement params are calculated based on the fuzzy systems FSAngle and FSVelocity
"""
car = vehicle.Car(constants.CAR_POS_X, constants.CAR_POS_Y,
constants.CAR_ANGLE)
iteration = 0
past_pos = car.center_position()
dec = decoder.Decoder(FSAngle, FSVelocity, car)
dt = TIME_STEP
total_distance = 0
punishment = 0
left_right = 0
while iteration <= MAX_ITERATIONS:
car.left_sensor_input, car.front_sensor_input, car.right_sensor_input = get_sensors(
car, road_matrix, memory)
ds, drot = dec.get_movement_params()
car.update(dt, ds, drot)
iteration += 1
total_distance += ds
left_right += abs(
float(car.left_sensor_input) - float(car.right_sensor_input))
if iteration % 100 == 0:
past_x, past_y = past_pos
curr_x, curr_y = car.center_position()
if vehicle.distance(past_x, past_y, curr_x, curr_y) < MIN_DISTANCE:
break
else:
past_pos = car.center_position()
if car.is_idle(iteration) or car.is_collided2(road_matrix):
punishment = 150
break
return left_right / iteration + punishment
def test_load_inputs_from_file(self):
car = vehicle.Car()
inputs = [[0.5, 0.25, -15], [0, 0, 0]]
test_inputs_file = open('test_inputs.csv', 'w')
for i in range(len(inputs)):
test_inputs_file.write(
f'{inputs[i][0]},{inputs[i][1]},{inputs[i][2]}\n')
test_inputs_file.close()
car.load_inputs(file='test_inputs.csv')
os.remove('test_inputs.csv')
car_input_buffer = car.input_buffer
for i in range(len(car_input_buffer)):
for j in range(len(car_input_buffer[i])):
car_input_buffer[i][j] = float(car_input_buffer[i][j])
self.assertEqual(inputs, car_input_buffer)
import vehicle
if __name__ == "__main__":
my_car = vehicle.Car()
my_car.start()
my_car.accelerate()
speed_mile = vehicle.change_km_to_mile(my_car.get_speed())
print('속도:', speed_mile, 'mile')
my_car.stop()
def test_car_orientation(self):
car = vehicle.Car(orientation=math.radians(360))
self.assertEqual(car.orientation, 0)
def setup_method(self):
print("setup_method car")
self.vehicle = vehicle.Car()
self.vehicle.set_num_wheels(3)
self.vehicle.set_capacity(4)
self.vehicle.turn_engine_on()
from car import Car
tesla = Car('Tesla')
Car.get_number_of_wheels()
print(tesla.get_number_of_wheels())
tesla.start()
print(str(tesla))
print(repr(tesla))
import vehicle
four_by_four = vehicle.Vehicle('zoom', 'fast', fuel='oil')
my_tesla = vehicle.Car('Tesla', 'x99', fuel='diessel')
print(my_tesla.make)
print(my_tesla.model)
print(my_tesla.fuel)
print(my_tesla.num_wheels)
print(my_tesla.is_eco_friendly())
import vehicle truck1 = vehicle.Truck() car1 = vehicle.Car() print(truck1)
def add_car(rego, model, color, price):
cars.append(vehicle.Car(rego, model, color, price))
