def draw_sections(self, width, height, scale):
t0, t1 = self.g_pool.timestamps[0], self.g_pool.timestamps[-1]
pixel_to_time_fac = height / (t1 - t0)
with gl_utils.Coord_System(t0, t1, height, 0):
gl.glTranslatef(0, 0.001 + scale * self.timeline_line_height / 2, 0)
for s in self.sections:
color = RGBA(1., 1., 1., .5)
if s['calibration_method'] == "natural_features":
draw_x([(m['timestamp'], 0) for m in self.manual_ref_positions],
height=12, width=3 * pixel_to_time_fac, thickness=scale, color=color)
else:
draw_bars([(m['timestamp'], 0) for m in self.circle_marker_positions],
height=12, thickness=scale, color=color)
cal_slc = slice(*s['calibration_range'])
map_slc = slice(*s['mapping_range'])
cal_ts = self.g_pool.timestamps[cal_slc]
map_ts = self.g_pool.timestamps[map_slc]
color = RGBA(*s['color'])
if len(cal_ts):
draw_polyline([(cal_ts[0], 0), (cal_ts[-1], 0)], color=color,
line_type=gl.GL_LINES, thickness=8*scale)
if len(map_ts):
draw_polyline([(map_ts[0], 0), (map_ts[-1], 0)], color=color,
line_type=gl.GL_LINES, thickness=2*scale)
gl.glTranslatef(0, scale * self.timeline_line_height, 0)
def gl_display(self):
# normalize coordinate system, no need this step in utility functions
with gl_utils.Coord_System(0, 1, 0, 1):
ref_point_norm = [r['norm_pos'] for r in self.circle_marker_positions
if self.g_pool.capture.get_frame_index() == r['index']]
cygl_utils.draw_points(ref_point_norm, size=35, color=cygl_utils.RGBA(0, .5, 0.5, .7))
cygl_utils.draw_points(ref_point_norm, size=5, color=cygl_utils.RGBA(.0, .9, 0.0, 1.0))
manual_refs_in_frame = [r for r in self.manual_ref_positions
if self.g_pool.capture.get_frame_index() in r['index_range']]
current = self.g_pool.capture.get_frame_index()
for mr in manual_refs_in_frame:
if mr['index'] == current:
cygl_utils.draw_points([mr['norm_pos']], size=35, color=cygl_utils.RGBA(.0, .0, 0.9, .8))
cygl_utils.draw_points([mr['norm_pos']], size=5, color=cygl_utils.RGBA(.0, .9, 0.0, 1.0))
else:
distance = abs(current - mr['index'])
range_radius = (mr['index_range'][-1] - mr['index_range'][0]) // 2
# scale alpha [.1, .9] depending on distance to current frame
alpha = distance / range_radius
alpha = 0.1 * alpha + 0.9 * (1. - alpha)
# Use draw_progress instead of draw_circle. draw_circle breaks
# because of the normalized coord-system.
cygl_utils.draw_progress(mr['norm_pos'], 0., 0.999,
inner_radius=20.,
outer_radius=35.,
color=cygl_utils.RGBA(.0, .0, 0.9, alpha))
cygl_utils.draw_points([mr['norm_pos']], size=5, color=cygl_utils.RGBA(.0, .9, 0.0, alpha))
# calculate correct timeline height. Triggers timeline redraw only if changed
self.timeline.content_height = max(0.001, self.timeline_line_height * len(self.sections))
def draw_activation(self, width, height, scale):
t0, t1 = self.g_pool.timestamps[0], self.g_pool.timestamps[-1]
response_points = tuple(zip(self.timestamps, self.filter_response))
if len(response_points) == 0:
return
class_points = deque([(t0, -.9)])
for b in self.g_pool.blinks:
class_points.append((b['start_timestamp'], -.9))
class_points.append((b['start_timestamp'], .9))
class_points.append((b['end_timestamp'], .9))
class_points.append((b['end_timestamp'], -.9))
class_points.append((t1, -.9))
thresholds = [(t0, self.onset_confidence_threshold),
(t1, self.onset_confidence_threshold),
(t0, -self.offset_confidence_threshold),
(t1, -self.offset_confidence_threshold)]
with gl_utils.Coord_System(t0, t1, -1, 1):
draw_polyline(response_points,
color=RGBA(0.6602, 0.8594, 0.4609, 0.8),
line_type=gl.GL_LINE_STRIP,
thickness=1 * scale)
draw_polyline(class_points,
color=RGBA(0.9961, 0.3789, 0.5313, 0.8),
line_type=gl.GL_LINE_STRIP,
thickness=1 * scale)
draw_polyline(thresholds,
color=RGBA(0.9961, 0.8438, 0.3984, 0.8),
line_type=gl.GL_LINES,
thickness=1 * scale)
def draw_fps(self, width, height, scale):
with gl_utils.Coord_System(*self.cache['xlim'], *self.cache['ylim']):
if self.show_world_fps:
draw_points(self.cache['world'], size=2*scale, color=world_color)
if self.show_eye_fps:
draw_points(self.cache['eye0'], size=2*scale, color=right_color)
draw_points(self.cache['eye1'], size=2*scale, color=left_color)
def draw_sections(self, width, height, scale):
max_ts = len(self.g_pool.timestamps)
with gl_utils.Coord_System(0, max_ts, height, 0):
gl.glTranslatef(0, 0.001 + scale * self.timeline_line_height / 2,
0)
for s in self.sections:
color = RGBA(1., 1., 1., .5)
if s['calibration_method'] == "natural_features":
draw_x([(m['index'], 0)
for m in self.manual_ref_positions],
size=12,
thickness=2 * scale,
color=color)
else:
draw_bars([(m['index'], 0)
for m in self.circle_marker_positions],
height=12,
thickness=scale,
color=color)
cal_slc = slice(*s['calibration_range'])
map_slc = slice(*s['mapping_range'])
color = RGBA(*s['color'])
draw_polyline([(cal_slc.start, 0), (cal_slc.stop, 0)],
color=color,
line_type=gl.GL_LINES,
thickness=8 * scale)
draw_polyline([(map_slc.start, 0), (map_slc.stop, 0)],
color=color,
line_type=gl.GL_LINES,
thickness=2 * scale)
gl.glTranslatef(0, scale * self.timeline_line_height, 0)
def gl_display_cache_bars(self, width, height, scale):
"""
"""
with gl_utils.Coord_System(0, self.cache.length - 1, height, 0):
# Lines for areas that have been cached
cached_ranges = []
for r in self.cache.visited_ranges: # [[0,1],[3,4]]
cached_ranges += (r[0], 0), (r[1], 0
) # [(0,0),(1,0),(3,0),(4,0)]
glTranslatef(0, scale * self.timeline_line_height / 2, 0)
color = RGBA(.8, .6, .2, .8)
draw_polyline(cached_ranges,
color=color,
line_type=GL_LINES,
thickness=scale * 4)
# Lines where surfaces have been found in video
cached_surfaces = []
for s in self.surfaces:
found_at = []
if s.cache is not None:
for r in s.cache.positive_ranges: # [[0,1],[3,4]]
found_at += (r[0], 0), (r[1], 0
) # [(0,0),(1,0),(3,0),(4,0)]
cached_surfaces.append(found_at)
color = RGBA(0, .7, .3, .8)
for s in cached_surfaces:
glTranslatef(0, scale * self.timeline_line_height, 0)
draw_polyline(s,
color=color,
line_type=GL_LINES,
thickness=scale * 2)
def draw_sections(self, width, height, scale):
t0, t1 = self.g_pool.timestamps[0], self.g_pool.timestamps[-1]
pixel_to_time_fac = height / (t1 - t0)
with gl_utils.Coord_System(t0, t1, height, 0):
gl.glTranslatef(0, 0.001 + scale * self.timeline_line_height / 2, 0)
for s in self.sections:
cal_slc = slice(*s['calibration_range'])
map_slc = slice(*s['mapping_range'])
cal_ts = self.g_pool.timestamps[cal_slc]
map_ts = self.g_pool.timestamps[map_slc]
color = cygl_utils.RGBA(*s['color'][:3], 1.)
if len(cal_ts):
cygl_utils.draw_rounded_rect((cal_ts[0], -4 * scale),
(cal_ts[-1] - cal_ts[0], 8 * scale),
corner_radius=0,
color=color,
sharpness=1.)
if len(map_ts):
cygl_utils.draw_rounded_rect((map_ts[0], -scale),
(map_ts[-1] - map_ts[0], 2 * scale),
corner_radius=0,
color=color,
sharpness=1.)
color = cygl_utils.RGBA(1., 1., 1., .5)
if s['calibration_method'] == "natural_features":
cygl_utils.draw_x([(m['timestamp'], 0) for m in self.manual_ref_positions],
height=12 * scale, width=3 * pixel_to_time_fac / scale, thickness=scale, color=color)
else:
cygl_utils.draw_bars([(m['timestamp'], 0) for m in self.circle_marker_positions],
height=12 * scale, thickness=scale, color=color)
gl.glTranslatef(0, scale * self.timeline_line_height, 0)
def draw_pupil_data(self, key, width, height, scale):
right = self.cache[key]['right']
left = self.cache[key]['left']
with gl_utils.Coord_System(*self.cache[key]['xlim'], *self.cache[key]['ylim']):
draw_points(right, size=2.*scale, color=right_color)
draw_points(left, size=2.*scale, color=left_color)
def draw_sections(self, width, height, scale):
with gl_utils.Coord_System(
left=self._time_start, right=self._time_end, bottom=height, top=0
):
self._translate_to_vertical_center_of_row(scale)
for row in self._rows:
self._draw_row(row, height, scale)
self._translate_to_next_row(scale)
def draw_activation(self, width, height, scale):
t0, t1 = self.g_pool.timestamps[0], self.g_pool.timestamps[-1]
with gl_utils.Coord_System(t0, t1, -1, 1):
draw_polyline(self.cache['response_points'], color=activity_color,
line_type=gl.GL_LINE_STRIP, thickness=scale)
draw_polyline(self.cache['class_points'], color=blink_color,
line_type=gl.GL_LINE_STRIP, thickness=scale)
draw_polyline(self.cache['thresholds'], color=threshold_color,
line_type=gl.GL_LINES, thickness=scale)
def draw_pupil_data(self, key, width, height, scale):
right = self.cache[key]["right"]
left = self.cache[key]["left"]
with gl_utils.Coord_System(*self.cache[key]["xlim"], *self.cache[key]["ylim"]):
cygl_utils.draw_points(
right, size=2.0 * scale, color=COLOR_LEGEND_EYE_RIGHT
)
cygl_utils.draw_points(left, size=2.0 * scale, color=COLOR_LEGEND_EYE_LEFT)
def draw_data(self, width, height, scale, channel):
with gl_utils.Coord_System(*self.cache["xlim"], *self.cache["ylim"]):
channels = np.shape(self.cache["data"])[1]
for i in range(channels):
channel_data =np.reshape(self.cache["data"][:,channel],(-1)).tolist()
whole_data = tuple(zip(channel_data, self.timestamps))
if len(channel_data) ==1:
return
cygl_utils.draw_points(
whole_data, size=2 * scale, color=COLOR_LEGEND_WORLD
)
def draw_pupil_data(self, key, width, height, scale):
right = self.cache[key]['right']
left = self.cache[key]['left']
with gl_utils.Coord_System(*self.cache[key]['xlim'],
*self.cache[key]['ylim']):
cygl_utils.draw_points(right,
size=2. * scale,
color=COLOR_LEGEND_EYE_RIGHT)
cygl_utils.draw_points(left,
size=2. * scale,
color=COLOR_LEGEND_EYE_LEFT)
def draw_fps(self, width, height, scale):
with gl_utils.Coord_System(*self.cache["xlim"], *self.cache["ylim"]):
if self.show_world_fps:
cygl_utils.draw_points(self.cache["world"],
size=2 * scale,
color=COLOR_LEGEND_WORLD)
if self.show_eye_fps:
cygl_utils.draw_points(self.cache["eye0"],
size=2 * scale,
color=COLOR_LEGEND_EYE_RIGHT)
cygl_utils.draw_points(self.cache["eye1"],
size=2 * scale,
color=COLOR_LEGEND_EYE_LEFT)
def draw_pupil_data(self, key, width, height, scale):
if not self.g_pool.pupil_positions:
return
t0, t1 = self.g_pool.timestamps[0], self.g_pool.timestamps[-1]
right = [(pp['timestamp'], pp[key]) for pp in self.g_pool.pupil_positions if pp['id'] == 0]
left = [(pp['timestamp'], pp[key]) for pp in self.g_pool.pupil_positions if pp['id'] == 1]
# max_val must not be 0, else gl will crash
max_val = max(chain((pp[1] for pp in right), (pp[1] for pp in left))) or 1
with gl_utils.Coord_System(t0, t1, 0, max_val):
draw_points(right, size=2.*scale, color=right_color)
draw_points(left, size=2.*scale, color=left_color)
def draw_data(self, width, height, scale):
if len(self.x[self.channel]) == 0:
return
x = self.x[self.channel] - self.x[self.channel][0]
xlim = [min(x), max(x) + 0.01]
ylim = [min(self.y[self.channel]), max(self.y[self.channel]) + 0.00001]
with gl_utils.Coord_System(*xlim, *ylim):
whole_data = tuple(
zip(self.x[self.channel] - self.x[self.channel][0],
self.y[self.channel]))
cygl_utils.draw_points(whole_data,
size=2 * scale,
color=COLOR_LEGEND_WORLD)
def _draw_grouped(self, data, keys, y_limits, width, height, scale):
ts_min = self.g_pool.timestamps[0]
ts_max = self.g_pool.timestamps[-1]
data_raw = data[keys]
sub_samples = np.linspace(
0,
self.data_len - 1,
min(self.NUMBER_SAMPLES_TIMELINE, self.data_len),
dtype=int,
)
with gl_utils.Coord_System(ts_min, ts_max, *y_limits):
for key in keys:
data_keyed = data_raw[key]
if data_keyed.shape[0] == 0:
continue
points = list(zip(self.data_ts[sub_samples], data_keyed[sub_samples]))
cygl_utils.draw_points(points, size=1.5 * scale, color=self.CMAP[key])
def _timeline_draw_data_cb(self, width, height, scale):
ts = self.g_pool.timestamps
with gl_utils.Coord_System(ts[0], ts[-1], height, 0):
# Lines for areas that have been cached
cached_ranges = []
for r in self.marker_cache.visited_ranges:
cached_ranges += ((ts[r[0]], 0), (ts[r[1]], 0))
gl.glTranslatef(0, scale * self.TIMELINE_LINE_HEIGHT / 2, 0)
color = pyglui_utils.RGBA(0.8, 0.2, 0.2, 0.8)
pyglui_utils.draw_polyline(cached_ranges,
color=color,
line_type=gl.GL_LINES,
thickness=scale * 4)
cached_ranges = []
for r in self.marker_cache.positive_ranges:
cached_ranges += ((ts[r[0]], 0), (ts[r[1]], 0))
color = pyglui_utils.RGBA(0, 0.7, 0.3, 0.8)
pyglui_utils.draw_polyline(cached_ranges,
color=color,
line_type=gl.GL_LINES,
thickness=scale * 4)
# Lines where surfaces have been found in video
cached_surfaces = []
for surface in self.surfaces:
found_at = []
if surface.location_cache is not None:
for r in surface.location_cache.positive_ranges: # [[0,1],[3,4]]
found_at += ((ts[r[0]], 0), (ts[r[1]], 0))
cached_surfaces.append(found_at)
color = pyglui_utils.RGBA(0, 0.7, 0.3, 0.8)
for surface in cached_surfaces:
gl.glTranslatef(0, scale * self.TIMELINE_LINE_HEIGHT, 0)
pyglui_utils.draw_polyline(surface,
color=color,
line_type=gl.GL_LINES,
thickness=scale * 2)
def draw_audio(self, width, height, scale):
with gl_utils.Coord_System(*self.xlim, *self.ylim):
draw_bars_buffer(self.audio_viz_data, color=viz_color)
def draw_audio(self, width, height, scale):
if self.audio_viz_data is None:
return
with gl_utils.Coord_System(*self.xlim, *self.ylim):
pyglui_utils.draw_bars_buffer(self.audio_viz_data, color=viz_color)
def _frame_coordinate_system(self):
return gl_utils.Coord_System(left=0,
right=self._frame_size[0],
bottom=self._frame_size[1],
top=0)
