def __init__(self):
#General parameters
self.start_input_thread()
self.sm = ScreenManager(self)
self.start_client()
track_letters = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I')
self.tracks = [Track(letter) for letter in track_letters]
self.default_loop()
def __init__(self):
self.sm = ScreenManager()
rospy.init_node('mira_screen', anonymous=True)
rospy.Subscriber("/mira_screen/input", Int8, self.callback)
rospy.Subscriber('/mira_screen/exit', Int8, self.exit_callback)
rospy.spin()
def drive(host, port, gpu_number, path, show_screen, resolution, noise_type,
config_path, type_of_driver, experiment_name, city_name, game,
drivers_name):
print "port:", port
use_planner = False
screen_manager = ScreenManager()
if game == "Carla":
from carla_recorder import Recorder
if type_of_driver == "Human":
from carla_human import CarlaHuman
driver = CarlaHuman(
use_planner,
'drive_interfaces/carla_interface/' + city_name + '.txt',
'drive_interfaces/carla_interface/' + city_name + '.png',
augment_left_right=False)
else:
from carla_machine import CarlaMachine
driver = CarlaMachine("0",experiment_name,use_planner,'drive_interfaces/carla_interface/' + city_name + '.txt',\
'drive_interfaces/carla_interface/' + city_name + '.png',augment_left_right=False)
'''if drive_config.interface == "VirtualElektra":
from carla_recorder import Recorder
if drive_config.type_of_driver == "Human":
from virtual_elektra_human import VirtualElektraHuman
driver = VirtualElektraHuman(drive_config)
else:
from virtual_elektra_carla_machine import VirtualElektraMachine
driver = VirtualElektraMachine("0",experiment_name,drive_config,memory_use)'''
noiser = Noiser(noise_type)
print host
print port
driver.start(host, port, config_path, resolution)
first_time = True
if show_screen:
screen_manager.start_screen(resolution, 3, 2)
folder_name = str(datetime.datetime.today(
).day) + '_' + 'Carla_' + type_of_driver + '_' + experiment_name
folder_name += '_' + str(get_latest_file_number(path, folder_name))
recorder = Recorder(path + folder_name + '/', 88, 200)
#Note: resolution size is 400,300. but we give input to network 200,100 by cropping it.
direction = 2
old_speed = 0 #the speed we start the car with
iteration = 0
try:
while direction != -1: #which never happens
capture_time = time.time()
direction_time = time.time()
rewards, image = driver.get_sensor_data()
for event in pygame.event.get(): # User did something
if event.type == pygame.QUIT: # If user clicked close
done = True # Flag that we are done so we exit this loop
recording = driver.get_recording()
action, new_speed, human_intervention = driver.compute_action(
old_speed, rewards, image
) #passing rewards so that finally carla speed = computed speed
#depending on driver being human or machine, new_speed can be the one given by driver or the network resp.
action_noisy, drifting_time, will_drift = noiser.compute_noise(
action)
if recording:
recorder.record(image, rewards, action, action_noisy,
human_intervention)
if show_screen:
if game == "Carla":
#print len(image)
screen_manager.plot_driving_interface(capture_time,np.copy(image),\
action,action_noisy,recording and (drifting_time == 0.0 or will_drift),\
drifting_time,will_drift,rewards.speed,new_speed,0,0,0,type_of_driver, driver.continous_steer, human_intervention) #
else:
dist_to_goal = math.sqrt(
(rewards.goal[0] - rewards.position[0]) *
(rewards.goal[0] - rewards.position[0]) +
(rewards.goal[1] - rewards.position[1]) *
(rewards.goal[1] - rewards.position[1]))
image = image[:, :, ::-1]
screen_manager.plot_driving_interface( capture_time,np.copy(image), action,action_noisy,\
rewards.direction,recording and (drifting_time == 0.0 or will_drift),drifting_time,will_drift\
,rewards.speed,0,0,None,rewards.reseted,driver.get_number_completions(),dist_to_goal,0) #
iteration += 1
old_speed = new_speed
driver.act(action_noisy)
except:
traceback.print_exc()
finally:
#driver.write_performance_file(path,folder_name,iteration)
pygame.quit()
if type_of_driver == "Machine":
print "Machine:", driver.machine_driving_count
print "Human:", driver.human_driving_count
autonomy = (float(driver.machine_driving_count) /
float(driver.machine_driving_count +
driver.human_driving_count)) * 100
print("Autonomy: {0:.2f}%".format(autonomy))
print "Machine checkpoint score:", driver.checkpoint_score
driver.tester.plot_map()
type=str,
default="ElektraData1_video",
help='Dataset/video clip name')
args = parser.parse_args()
dataset = args.dataset
first_time = True
count = 0
steering_pred = []
steering_gt = []
positions_to_test = range(7, 15) #total hdf5 files
path = '../Desktop/VirtualElektraData2_W1/SeqTrain/'
screen = ScreenManager()
image_queue = deque()
speed_list = []
steer_list = []
noisy_steer_list = []
actions_queue = deque()
screen.start_screen([200, 88], 1, 2)
images = np.array([200, 88, 3])
actions = Control()
for h_num in positions_to_test:
print(dialPins)
print(dials)
for dial in sorted(dials.items()):
print(dial[0])
inputs.add_input(dialPins[counter], list(dials[dial[0]]), dial[0], 1024)
counter += 1
button = ButtonManager(go_pin=18,
reset_pin=23,
go_ahead_light=12,
stop_light=17,
reset_time=0,
go_sound='/home/pi/pox/client/go.wav',
reset_sound='/home/pi/pox/client/reset.wav')
screen = ScreenManager("Enter Phone #\nand Pull Lever")
# Create new threads
thread1 = InputThread(1, "Input Manager Thread", 1, inputs)
#thread2 = ScreenThread(2, "Screen Manager Thread", ScreenManager())
# Start new Threads
thread1.start()
#thread2.start()
if len(sys.argv) == 2 and sys.argv[1] == 'debug':
while (1):
print(thread1.get_readings())
while (1):
check = button.check()
# Button hasn't been pressed and hasn't been reset
if check == 0:
import pyglet
from screen_manager import ScreenManager
window = pyglet.window.Window(fullscreen=True)
screen_manager = ScreenManager(window)
@window.event
def on_draw():
window.clear()
screen_manager.on_draw()
pyglet.app.run()
class MainApp(App):
sm = ScreenManager(transition=FadeTransition())
def build(self):
return self.sm
import pygame
from screen_manager import ScreenManager
pygame.init()
resolution = (1280, 720)
display = pygame.display.set_mode(resolution)
clock = pygame.time.Clock()
running = True
manager = ScreenManager(resolution)
while running:
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
running = False # Force quit the game
display.fill((0, 0, 0)) # Black out the screen for a new flip
manager.update(display, events)
if not manager.active:
running = False # quit the game if ScreenManager ended.
# Render the screen
pygame.display.flip()
clock.tick(30) # Lock at 30FPS
def setup(self):
logger.info("Starting setup")
signal(SIGTERM, signal_term_handler)
# Python game ######################
logger.info("Setting pygame")
pygame_init_done = False
while not pygame_init_done:
try:
pygame.init()
pygame_init_done = True
except:
logger.debug("Pygame init failed")
pygame_init_done = False
time.sleep(5)
pygame.mouse.set_visible(False)
# Hax for freezing
signal(SIGALRM, alarm_handler)
alarm(1)
try:
# Set screen size
size = width, height = config.resolution
self.screen = pygame.display.set_mode(size)
alarm(0)
except Alarm:
logger.debug("Keyboard interrupt?")
raise KeyboardInterrupt
# Hax end
logger.info("Display driver: %s" % pygame.display.get_driver())
# Player control ###############
logger.info("Setting player control")
self.pc = PlayerControl()
logger.debug("Player control set")
# Screen manager ###############
logger.info("Setting screen manager")
self.sm = ScreenManager(path, self.pc)
logger.debug("Screen manager set")
# LIRC
lircrcfile = path + config.lircrcfile
self.lirc_enabled = False
if os.path.isfile(lircrcfile):
try:
self.lirc_sockid = lirc.init("pitft-playerui",
lircrcfile,
blocking=False)
self.lirc_enabled = True
except Exception as e:
logger.error(e)
self.lirc_enabled = False
# Mouse variables
self.clicktime = datetime.datetime.now()
self.longpress_time = timedelta(milliseconds=300)
self.click_filtertime = datetime.datetime.now()
self.click_filterdelta = timedelta(milliseconds=10)
self.scroll_threshold = (20, 20)
self.start_pos = 0, 0
self.mouse_scroll = ""
self.mousebutton_down = False
self.pos = 0
# Smooth scrolling variables
self.smoothscroll = False
self.smoothscroll_direction = 0, 0
self.smoothscroll_directions_index = 0
self.smoothscroll_direction_samples = 10
self.smoothscroll_directions = [0
] * self.smoothscroll_direction_samples
self.smoothscroll_factor = 0.9
self.smoothscroll_timedelta = timedelta(milliseconds=1)
self.smoothscroll_time = datetime.datetime.now()
# Times in milliseconds
self.screen_refreshtime = 16.67
self.player_refreshtime = 200
#Backlight
self.screen_timer = 0.0
self.backlight = False
self.update_screen_timeout(True)
logger.debug("Setup done")
def drive_elektra(
experiment_name,
drive_config,
input_method,
name=None,
memory_use=1.0,
):
driver, recorder = get_instance(drive_config, experiment_name, name,
memory_use, input_method)
noiser = Noiser(drive_config.noise)
#print 'before starting'
driver.start()
first_time = True
if drive_config.show_screen:
screen_manager = ScreenManager()
screen_manager.start_screen(drive_config.resolution,
drive_config.number_screens,
drive_config.scale_factor)
driver.use_planner = False
old_speed = 0 #the speed we start the car with
direction = 2
iteration = 0
try:
while direction != -1:
capture_time = time.time()
images = driver.get_sensor_data()
for event in pygame.event.get(): # User did something
if event.type == pygame.QUIT: # If user clicked close
done = True # Flag that we are done so we exit this loop
recording = driver.get_recording(
) #just booleans, received from joystick
driver.get_reset() #just booleans, received from joystick
action, new_speed, human_intervention = driver.compute_action(
images, old_speed) #rewards.speed
#action_noisy,drifting_time,will_drift = noiser.compute_noise(action[drive_config.middle_camera])
action_noisy, drifting_time, will_drift = noiser.compute_noise(
action)
if recording:
print "RECORDING"
recorder.record(images, action.speed, action.steer,
action_noisy.steer, human_intervention)
'''if drive_config.show_screen:
if drive_config.interface == "Carla":
for i in range(drive_config.number_screens-1):
screen_manager.plot_driving_interface( capture_time,np.copy(images[i]),\
action[i],action_noisy,driver.compute_direction((rewards.player_x,rewards.player_y,22),(rewards.ori_x,rewards.ori_y,rewards.ori_z)),recording and (drifting_time == 0.0 or will_drift),\
drifting_time,will_drift,rewards.speed,0,0,i) #
else:
print "Not supported interface"
pass'''
'''if drive_config.type_of_driver == "Machine" and drive_config.show_screen and drive_config.plot_vbp:
image_vbp =driver.compute_perception_activations(images[drive_config.middle_camera],rewards.speed)
screen_manager.plot_image(image_vbp,1)'''
iteration += 1
old_speed = new_speed
driver.act(action_noisy)
except:
traceback.print_exc()
finally:
driver.end()
#driver.write_performance_file(path,folder_name,iteration)
pygame.quit()