def position_windows(self):
cv2.moveWindow('Data Visualizer', 0, 0)
img_height = int(self.video_viz.video_height)
img_width = int(self.video_viz.video_width)
self.radar_viz = RadarVisualizer(img_height / 2 - 10,
img_height / 2 - 10, CHANNELS)
self.dsrc_viz = DsrcVisualizer(img_height / 2 - 10,
img_height / 2 - 10, CHANNELS)
cv2.moveWindow('Radar', img_width + 5, 0)
cv2.moveWindow('DSRC', img_width + 5, img_height / 2 + 15)
def position_windows(self):
cv2.moveWindow('Data Visualizer', 0, 0)
img_height = int(self.video_viz.video_height)
img_width = int(self.video_viz.video_width)
self.radar_viz = RadarVisualizer(img_height/2 - 10, img_height/2 - 10, CHANNELS)
self.dsrc_viz = DsrcVisualizer(img_height/2 - 10, img_height/2 - 10, CHANNELS)
cv2.moveWindow('Radar', img_width + 5, 0)
cv2.moveWindow('DSRC', img_width + 5, img_height/2 + 15)
class CollisionAvoidance(Process):
""" Takes combined data and displays predicted collisions.
This package is included mainly for the purpose of demonstration.
It takes the information provided by our Combiner and calculates any predicted
collisions displaying warnings in a simple UI.
"""
def __init__(self, queue, video_file, export_interval, export_directory):
"""Setup the CA class, just empty state for now"""
Process.__init__(self)
self.queue = queue
self.video_file = video_file
self.export_interval = export_interval
self.export_directory = export_directory
self.current_state = None
self.constants = CollisionConstants()
signal.signal(signal.SIGINT, self.signal_handler)
def signal_handler(self, signal, frame):
print 'You pressed Ctrl+C!'
self.terminate()
def position_windows(self):
cv2.moveWindow('Data Visualizer', 0, 0)
img_height = int(self.video_viz.video_height)
img_width = int(self.video_viz.video_width)
self.radar_viz = RadarVisualizer(img_height / 2 - 10,
img_height / 2 - 10, CHANNELS)
self.dsrc_viz = DsrcVisualizer(img_height / 2 - 10,
img_height / 2 - 10, CHANNELS)
cv2.moveWindow('Radar', img_width + 5, 0)
cv2.moveWindow('DSRC', img_width + 5, img_height / 2 + 15)
def run(self):
print "Starting visualizer"
if not ENABLE:
print "No open cv found, giving up"
return
# Init vizualizers
self.video_viz = VideoOverlayVisualizer(self.video_file, self.export_interval, self.export_directory, 1.2446, -0.2, 3.4, 94.4, \
21.0/1000, 4.55/1000)
# self.video_viz = VideoOverlayVisualizer(self.video_file, 1.2446, -0.4, 0, 64.6, \
# 28.0/1000, 4.55/1000)
self.position_windows()
delay_remainder = 0.0
start_time = timeit.default_timer()
while True:
# Start timing to record how long our drawing takes
start_frame_time = timeit.default_timer()
# Get the last element from the data queue (get rid of any old data too)
while self.queue.qsize() > 1:
try:
self.current_state = self.queue.get(False)
except Empty:
break
# if we don't have data yet, don't bother visualizing
if not self.current_state:
continue
# If we are behind in the video compared to real time, grab a new
# frame until we are back in time
while self.video_viz.camera.get(cv2.CAP_PROP_POS_MSEC) < (
timeit.default_timer() - start_time) * 1000:
self.video_viz.camera.grab() # skip frames
# Run the video visualization, it returns false at the end of the video
# thus we kill the visualization at that point
if not self.video_viz.update(self.current_state):
print "End of video, killing viz"
break
# run our other visualizations
self.radar_viz.update(self.current_state)
self.dsrc_viz.update(self.current_state)
# Calculate how long to delay before next frame
single_frame_duration = float(1000) / self.video_viz.fps
vis_drawing_time = (timeit.default_timer() -
start_frame_time) * 1000
delay_before_next_frame = single_frame_duration - vis_drawing_time + delay_remainder
# if the amount of time we are supposed to delay is < 1ms then drop
# frames until our delay is possible. Basically if it took us more than
# single_frame_duration to draw the visualization on the current frame
# then we need to drop frames subsequent frames until we have a delay
# time > 0 (we are "catching up" with the video's natural frame rate)
frame_count = 1
while delay_before_next_frame < 1:
delay_before_next_frame = delay_before_next_frame + single_frame_duration
self.video_viz.camera.grab(
) # Get the next frame (aka skip it)
# Keep track of the fractional part of our delay as a remainder so we don't
# lose precision over time (if we are supposed to delay 1.5ms then 1.5ms we want
# to delay 1ms then 2ms so the total time will still be 3ms, we can't delay fractional
# milliseconds unfortunately)
delay_remainder = int(
delay_before_next_frame) - delay_before_next_frame
# Wait until it is time to display the next frame
cv2.waitKey(int(delay_before_next_frame))
class CollisionAvoidance(Process):
""" Takes combined data and displays predicted collisions.
This package is included mainly for the purpose of demonstration.
It takes the information provided by our Combiner and calculates any predicted
collisions displaying warnings in a simple UI.
"""
def __init__(self, queue, video_file, export_interval, export_directory):
"""Setup the CA class, just empty state for now"""
Process.__init__(self)
self.queue = queue
self.video_file = video_file
self.export_interval = export_interval
self.export_directory = export_directory
self.current_state = None
self.constants = CollisionConstants()
signal.signal(signal.SIGINT, self.signal_handler)
def signal_handler(self, signal, frame):
print 'You pressed Ctrl+C!'
self.terminate()
def position_windows(self):
cv2.moveWindow('Data Visualizer', 0, 0)
img_height = int(self.video_viz.video_height)
img_width = int(self.video_viz.video_width)
self.radar_viz = RadarVisualizer(img_height/2 - 10, img_height/2 - 10, CHANNELS)
self.dsrc_viz = DsrcVisualizer(img_height/2 - 10, img_height/2 - 10, CHANNELS)
cv2.moveWindow('Radar', img_width + 5, 0)
cv2.moveWindow('DSRC', img_width + 5, img_height/2 + 15)
def run(self):
print "Starting visualizer"
if not ENABLE:
print "No open cv found, giving up"
return
# Init vizualizers
self.video_viz = VideoOverlayVisualizer(self.video_file, self.export_interval, self.export_directory, 1.2446, -0.2, 3.4, 94.4, \
21.0/1000, 4.55/1000)
# self.video_viz = VideoOverlayVisualizer(self.video_file, 1.2446, -0.4, 0, 64.6, \
# 28.0/1000, 4.55/1000)
self.position_windows()
delay_remainder = 0.0;
start_time = timeit.default_timer()
while True:
# Start timing to record how long our drawing takes
start_frame_time = timeit.default_timer()
# Get the last element from the data queue (get rid of any old data too)
while self.queue.qsize() > 1:
try:
self.current_state = self.queue.get(False)
except Empty:
break
# if we don't have data yet, don't bother visualizing
if not self.current_state:
continue
# If we are behind in the video compared to real time, grab a new
# frame until we are back in time
while self.video_viz.camera.get(cv2.CAP_PROP_POS_MSEC) < (timeit.default_timer() - start_time) * 1000:
self.video_viz.camera.grab() # skip frames
# Run the video visualization, it returns false at the end of the video
# thus we kill the visualization at that point
if not self.video_viz.update(self.current_state):
print "End of video, killing viz"
break
# run our other visualizations
self.radar_viz.update(self.current_state)
self.dsrc_viz.update(self.current_state)
# Calculate how long to delay before next frame
single_frame_duration = float(1000)/self.video_viz.fps
vis_drawing_time = (timeit.default_timer() - start_frame_time) * 1000
delay_before_next_frame = single_frame_duration - vis_drawing_time + delay_remainder
# if the amount of time we are supposed to delay is < 1ms then drop
# frames until our delay is possible. Basically if it took us more than
# single_frame_duration to draw the visualization on the current frame
# then we need to drop frames subsequent frames until we have a delay
# time > 0 (we are "catching up" with the video's natural frame rate)
frame_count = 1
while delay_before_next_frame < 1:
delay_before_next_frame = delay_before_next_frame + single_frame_duration
self.video_viz.camera.grab() # Get the next frame (aka skip it)
# Keep track of the fractional part of our delay as a remainder so we don't
# lose precision over time (if we are supposed to delay 1.5ms then 1.5ms we want
# to delay 1ms then 2ms so the total time will still be 3ms, we can't delay fractional
# milliseconds unfortunately)
delay_remainder = int(delay_before_next_frame) - delay_before_next_frame
# Wait until it is time to display the next frame
cv2.waitKey(int(delay_before_next_frame))
