def _show_custom_ui(self):
width = 250
height = 100
draw_list = imgui.get_window_draw_list()
plot_start = imgui.get_cursor_screen_pos()
imgui.push_style_color(imgui.COLOR_PLOT_LINES, 0.8, 0.8, 0.8, 1.0)
imgui.plot_lines("",
self._beat_value_buffer.contents * self.get("gain"),
0.0, 1.0, (width, height))
imgui.pop_style_color()
plot_size = imgui.get_item_rect_size()
beat_risings = self._beat_rising_buffer.contents
count = self._beat_rising_buffer.size
for i, beat_rising in enumerate(beat_risings):
if not beat_rising:
continue
x = i / (count - 1) * width
line_start = plot_start[0] + x, plot_start[1]
line_end = plot_start[0] + x, plot_start[1] + height
draw_list.add_line(line_start, line_end,
imgui.get_color_u32_rgba(0.0, 0.8, 0.0, 0.8))
threshold = min(1.0, max(0.0, self.get("threshold")))
threshold_start = plot_start[0], plot_start[1] + (1.0 -
threshold) * height
threshold_end = plot_start[0] + width, threshold_start[1]
draw_list.add_line(threshold_start, threshold_end,
imgui.get_color_u32_rgba(0.8, 0.0, 0.0, 0.8))
def draw_map_wall(draw_list, wall, highlight=False):
is_portal = wall.adj_sector_idx != -1
tbl = [
# not highlighted
wall_default,
portal_default,
# highlighted
wall_highlight,
portal_highlight
]
color = tbl[(highlight << 1 | is_portal)]
v1 = wall.v1
v2 = wall.v2
((n1x, n1y), (n2x, n2y)) = wall.centered_normal()
cam_x = cur_state.camera_x
cam_y = cur_state.camera_y
draw_list.add_line(v1.x - cam_x, v1.y - cam_y, v2.x - cam_x, v2.y - cam_y,
imgui.get_color_u32_rgba(*color), 1.0)
draw_list.add_line(n1x - cam_x, n1y - cam_y, n2x - cam_x, n2y - cam_y,
imgui.get_color_u32_rgba(*color), 1.0)
def render_layers(view):
"Layer selector. Currently extremely spare."
index = view.index
# changed, new_index = imgui.v_slider_int("##layer_index", 30, 100, index,
# min_value=0, max_value=n_layers - 1)
# if changed:
# x, y, z = view.direction
# delta = new_index - index
# view.switch_layer(delta)
# imgui.same_line()
draw_list = imgui.get_window_draw_list()
x, y = imgui.get_cursor_screen_pos()
draw_list.add_rect_filled(x, y, x + 30, y + 100,
imgui.get_color_u32_rgba(0.5, 0.5, 0.5, 1))
top_layer = view.depth
h = 100 / top_layer
for layer in view.hidden_layers:
dy = 100 - 100 * (view.index_of_layer(layer) + 1) / top_layer
draw_list.add_rect_filled(x, y + dy, x + 30, y + dy + h,
imgui.get_color_u32_rgba(0.5, 0.1, 0.1, 1))
dy = 100 - 100 * (index + 1) / top_layer
draw_list.add_rect_filled(x, y + dy, x + 30, y + dy + h,
imgui.get_color_u32_rgba(1, 1, 1, 0.5))
imgui.set_cursor_screen_pos((x, y))
imgui.text(str(index))
def draw(self):
imgui.new_frame()
imgui.set_next_window_position(16, 32, imgui.ONCE)
imgui.set_next_window_size(256, 256, imgui.ONCE)
imgui.begin("Circle")
draw_list = imgui.get_window_draw_list()
draw_list.add_circle(100,
60,
30,
imgui.get_color_u32_rgba(1, 1, 0, 1),
thickness=3)
imgui.end()
imgui.set_next_window_position(270, 32, imgui.ONCE)
imgui.set_next_window_size(256, 256, imgui.ONCE)
imgui.begin("Filled Circle")
draw_list = imgui.get_window_draw_list()
draw_list.add_circle_filled(100, 60, 30,
imgui.get_color_u32_rgba(1, 1, 0, 1))
imgui.end()
imgui.end_frame()
imgui.render()
self.renderer.render(imgui.get_draw_data())
def render_turns(self, scale, rectmin):
turns = self.pts['turn']
Nturns = len(turns)
if Nturns < 3:
return
t = np.float32(turns).T
t[1] = -t[1] # invert y
tx = tapetrack.trackexport(t)
N = 100 * Nturns
s = (tapetrack.tracksubdiv(tx, N) * scale)
s[:, 0] += rectmin[0]
s[:, 1] = rectmin[1] - s[:, 1] # uninvert y
s[:, 3] = -s[:, 3]
L = s[:, :2] + s[:, 2:4] * self.lanewidth
R = s[:, :2] - s[:, 2:4] * self.lanewidth
dl = imgui.get_window_draw_list()
cyan = imgui.get_color_u32_rgba(0, 1, 1, 1)
yellow = imgui.get_color_u32_rgba(1, 1, 0, 1)
for i in range(1 + N):
a = i % N
b = (i + 1) % N
if i & 1:
dl.add_line(s[a, 0], s[a, 1], s[b, 0], s[b, 1], yellow)
dl.add_line(L[a, 0], L[a, 1], L[b, 0], L[b, 1], cyan)
dl.add_line(R[a, 0], R[a, 1], R[b, 0], R[b, 1], cyan)
return s
def drawMap(linesc,
east,
north,
xbias=1300,
ybias=100,
scale=0.5,
edge_color='#ff0000',
edge_linewidth=1,
edge_alpha=1):
draw_list = imgui.get_window_draw_list()
pos = imgui.core.get_window_position()
for p in linesc:
points = ((p - [east, north]) * [1, -1] /
[1.141255544679108e-5, 8.993216192195822e-6] +
[xbias, ybias]) * scale + [pos[0], pos[1]]
if (len(points) > 2):
draw_list.add_polyline(list(points),
imgui.get_color_u32_rgba(
1, 0, 0, edge_alpha),
closed=False,
thickness=edge_linewidth)
else:
draw_list.add_line(points[0][0], points[0][1], points[1][0],
points[1][1],
imgui.get_color_u32_rgba(1, 0, 0, edge_alpha),
edge_linewidth)
def draw(self):
imgui.begin("Line")
draw_list = imgui.get_window_draw_list()
draw_list.add_line(20, 35, 180, 80,
imgui.get_color_u32_rgba(1, 1, 0, 1), 3)
draw_list.add_line(180, 35, 20, 80,
imgui.get_color_u32_rgba(1, 0, 0, 1), 3)
imgui.end()
def ProgessBar(CV, MV, BarSize = 200):
if CV >= MV:
CV = MV
imgui.dummy(10, 20)
draw_list = imgui.get_window_draw_list()
sp = imgui.get_item_rect_min()
ep = imgui.get_item_rect_max()
draw_list.add_rect(sp[0]+60,ep[1], sp[0]+60 + BarSize ,sp[1], imgui.get_color_u32_rgba(0.098, 0.098, 0.439, 1))
draw_list.add_rect_filled(sp[0]+60,ep[1], sp[0]+60 + CV/MV * BarSize ,sp[1], imgui.get_color_u32_rgba(0.098, 0.098, 0.439, 1))
draw_list.add_text(sp[0]+60 + BarSize + 10, sp[1] + 2, imgui.get_color_u32_rgba(1,0.5,0.5,1), f'{round(CV/MV* 100, 2)} %')
def draw(self):
imgui.begin("Poly Line Overlay")
draw_list = imgui.get_overlay_draw_list()
draw_list.add_polyline([(20, 35), (90, 35), (55, 80)],
imgui.get_color_u32_rgba(1, 1, 0, 1),
closed=False,
thickness=3)
draw_list.add_polyline([(110, 35), (180, 35), (145, 80)],
imgui.get_color_u32_rgba(1, 0, 0, 1),
closed=True,
thickness=3)
imgui.end()
def draw(self):
imgui.begin("Image example")
texture_id = imgui.get_io().fonts.texture_id
draw_list = imgui.get_window_draw_list()
draw_list.add_image(texture_id, (128, 64), (512, 256),
col=imgui.get_color_u32_rgba(0.5, 0.5, 1, 1))
imgui.end()
def draw(self):
imgui.new_frame()
pos_x = 10
pos_y = 10
sz = 20
draw_list = imgui.get_window_draw_list()
for i in range(0, imgui.COLOR_COUNT):
name = imgui.get_style_color_name(i)
draw_list.add_rect_filled(pos_x, pos_y, pos_x + sz, pos_y + sz,
imgui.get_color_u32_idx(i))
imgui.dummy(sz, sz)
imgui.same_line()
rgba_color = imgui.get_color_u32_rgba(1, 1, 0, 1)
draw_list.add_rect_filled(pos_x, pos_y, pos_x + sz, pos_y + sz,
rgba_color)
imgui.end_frame()
imgui.render()
self.renderer.render(imgui.get_draw_data())
def draw(self):
x, y = self.output.get_position()
x1, y1 = self.input.get_position()
draw_list = imgui.get_overlay_draw_list()
#arcade.draw_line(x,y,x1,y1,(arcade.color.AQUA))
draw_list.add_line(x, y, x1, y1, imgui.get_color_u32_rgba(1, 1, 1, 1),
1)
def render_selection_rectangle(window, p0, p1, color=(1, 1, 0, 1)):
with invisible_window(window):
w, h = window.get_size()
x0, y0 = p0
x1, y1 = p1
draw_list = imgui.get_window_draw_list()
draw_list.add_rect(int(x0), int(h - y0), int(x1), int(h - y1),
imgui.get_color_u32_rgba(*color))
def render_selection_line(window, p0, p1):
with invisible_window(window):
imgui.text("hej")
x0, y0 = p0
x1, y1 = p1
draw_list = imgui.get_window_draw_list()
draw_list.add_line(x0, y0, x1, y1,
imgui.get_color_u32_rgba(1, 1, 0, 1), 2)
def assign_parameter_colors(node_library):
global params_color
global params_color_palette
global params_color_palette_index
for parameters_name in node_library.parameters:
col = params_color_palette[params_color_palette_index]
imgui_col = imgui.get_color_u32_rgba(col[0], col[1], col[2], 0.7)
params_color[node_library.parameters[parameters_name].get().type] = imgui_col
params_color_palette_index = params_color_palette_index + 1
def draw(self):
imgui.begin("Circle")
draw_list = imgui.get_window_draw_list()
draw_list.add_circle(100,
60,
30,
imgui.get_color_u32_rgba(1, 1, 0, 1),
thickness=3)
imgui.end()
def render_map(self):
imgui.begin("map")
imgui.slider_float("x (m)",
self.track[self.i, 0] * ceiltrack.CEIL_HEIGHT, -80,
80)
imgui.slider_float("y (m)",
self.track[self.i, 1] * ceiltrack.CEIL_HEIGHT, -80,
80)
imgui.slider_float("theta", self.track[self.i, 2] % (np.pi * 2), -7, 7)
imgui.slider_float("x (grid)",
self.track[self.i, 0] / ceiltrack.X_GRID, -10, 10)
imgui.slider_float("y (grid)",
self.track[self.i, 1] / ceiltrack.X_GRID, -10, 10)
changed, self.ceilheight = imgui.slider_float("ceiling height (m)",
self.ceilheight, 2, 4)
if changed:
self.loadframe(self.i)
dl = imgui.get_window_draw_list()
pos = imgui.get_cursor_screen_pos()
siz = imgui.get_content_region_available()
if siz[1] == 0:
siz = [400, 300]
# just use a fixed size
w = siz[0]
imgui.image_button(self.floortex, w, w / 2, frame_padding=0)
# imgui.image_button(self.floortex, siz[0], siz[0])
origin = [pos[0], pos[1]]
scale = 50 * ceiltrack.CEIL_HEIGHT * w / 1000
trackcolor = imgui.get_color_u32_rgba(0.3, 0.5, 0.3, 1)
for i in range(1, self.i):
dl.add_line(origin[0] + scale * self.track[i - 1, 0],
origin[1] + scale * self.track[i - 1, 1],
origin[0] + scale * self.track[i, 0],
origin[1] + scale * self.track[i, 1], trackcolor, 1.5)
carcolor = imgui.get_color_u32_rgba(0, 1, 0.6, 1)
B = self.track[self.i]
dl.add_line(origin[0] + scale * B[0], origin[1] + scale * B[1],
origin[0] + scale * (B[0] + np.cos(B[2])),
origin[1] + scale * (B[1] - np.sin(B[2])), carcolor, 1.5)
imgui.end()
def add_rect_coords(draw_list, top_left: Vec2, bottom_right: Vec2,
color) -> IMGui[None]:
""" Necessary because i haven't added the bindings for add_rect yet """
top_right = Vec2(bottom_right.x, top_left.y)
bottom_left = Vec2(top_left.x, bottom_right.y)
# draw rect clockwise from top left
color = im.get_color_u32_rgba(*color)
draw_list.add_line(*top_left, *top_right, col=color)
draw_list.add_line(*top_right, *bottom_right, col=color)
draw_list.add_line(*bottom_right, *bottom_left, col=color)
draw_list.add_line(*bottom_left, *top_left, col=color)
def draw_map_vert(draw_list, vert, highlight=False):
if highlight:
color = vert_highlight
else:
color = vert_default
cam_x = cur_state.camera_x
cam_y = cur_state.camera_y
draw_list.add_circle_filled(vert.x - cam_x,
vert.y - cam_y,
2,
imgui.get_color_u32_rgba(*color),
num_segments=12)
def draw(self):
imgui.new_frame()
imgui.set_next_window_position(16, 32, imgui.ONCE)
imgui.set_next_window_size(256, 256, imgui.ONCE)
imgui.begin("Rectangle")
draw_list = imgui.get_window_draw_list()
draw_list.add_rect(20,
35,
90,
80,
imgui.get_color_u32_rgba(1, 1, 0, 1),
thickness=3)
draw_list.add_rect(110,
35,
180,
80,
imgui.get_color_u32_rgba(1, 0, 0, 1),
rounding=5,
thickness=3)
imgui.end()
imgui.set_next_window_position(270, 32, imgui.ONCE)
imgui.set_next_window_size(256, 256, imgui.ONCE)
imgui.begin("Filled Rectangle")
draw_list = imgui.get_window_draw_list()
draw_list.add_rect_filled(20, 35, 90, 80,
imgui.get_color_u32_rgba(1, 1, 0, 1))
draw_list.add_rect_filled(110, 35, 180, 80,
imgui.get_color_u32_rgba(1, 0, 0, 1), 5)
imgui.end()
imgui.end_frame()
imgui.render()
self.renderer.render(imgui.get_draw_data())
def render_ptlist(self,
dl,
ptlist,
rectmin,
scale,
col,
r,
select=False,
lines=False):
lastuv = None
for i, p in enumerate(ptlist):
u = p[0] * scale + rectmin[0]
v = p[1] * scale + rectmin[1]
dl.add_rect_filled(u - r, v - r, u + r, v + r, col, r)
if select and i == self.selectedpt:
dl.add_rect(u - r + 1.5, v - r + 1.5, u + r + 1.5, v + r + 1.5,
imgui.get_color_u32_rgba(1, 1, 1, 1), r + 1)
else:
dl.add_rect(u - r + .5, v - r + .5, u + r + .5, v + r + .5,
imgui.get_color_u32_rgba(0, 0, 0, 1), r + 1)
if lines and lastuv is not None:
dl.add_line(lastuv[0], lastuv[1], u, v, col)
lastuv = (u, v)
def draw(self):
imgui.new_frame()
imgui.set_next_window_position(16, 32, imgui.ONCE)
imgui.set_next_window_size(512, 512, imgui.ONCE)
imgui.begin("Line")
draw_list = imgui.get_window_draw_list()
draw_list.add_line(20, 35, 180, 80, imgui.get_color_u32_rgba(1,1,0,1), 3)
draw_list.add_line(180, 35, 20, 80, imgui.get_color_u32_rgba(1,0,0,1), 3)
imgui.end()
imgui.begin("Poly Line")
draw_list = imgui.get_window_draw_list()
draw_list.add_polyline([(20, 35), (90, 35), (55, 80)], imgui.get_color_u32_rgba(1,1,0,1), closed=False, thickness=3)
draw_list.add_polyline([(110, 35), (180, 35), (145, 80)], imgui.get_color_u32_rgba(1,0,0,1), closed=True, thickness=3)
imgui.end()
imgui.end_frame()
imgui.render()
self.renderer.render(imgui.get_draw_data())
def draw(self):
imgui.new_frame()
imgui.set_next_window_position(16, 32, imgui.ONCE)
imgui.set_next_window_size(512, 512, imgui.ONCE)
imgui.begin("Text")
draw_list = imgui.get_window_draw_list()
draw_list.add_text(20, 35, imgui.get_color_u32_rgba(1, 1, 0, 1),
"Hello!")
imgui.end()
imgui.end_frame()
imgui.render()
self.renderer.render(imgui.get_draw_data())
def draw(self):
imgui.new_frame()
imgui.set_next_window_position(16, 32, imgui.ONCE)
imgui.set_next_window_size(512, 512, imgui.ONCE)
imgui.begin("Font image example")
texture_id = imgui.get_io().fonts.texture_id
draw_list = imgui.get_window_draw_list()
draw_list.add_image(texture_id, (20, 35), (180, 80),
col=imgui.get_color_u32_rgba(0.5, 0.5, 1, 1))
imgui.end()
imgui.end_frame()
imgui.render()
self.renderer.render(imgui.get_draw_data())
def zoomtip(imtex, imdim, mag=1.0):
if imgui.is_item_hovered():
w, h = imgui.get_window_size()
h = imdim[0] * w / imdim[1]
rectmin = imgui.get_item_rect_min()
mousepos = imgui.get_mouse_pos()
u = float(mousepos[0] - rectmin[0]) / w
v = float(mousepos[1] - rectmin[1]) / h
imgui.begin_tooltip()
tw = 32. / imdim[1] / mag
th = 32. / imdim[0] / mag
imgui.image(imtex, 64, 64, uv0=(u - tw, v - th), uv1=(u + tw, v + th))
dl = imgui.get_window_draw_list()
rm = imgui.get_item_rect_min()
col = imgui.get_color_u32_rgba(1, 1, 0, 1)
dl.add_line(rm[0], rm[1] + 32, rm[0] + 64, rm[1] + 32, col)
dl.add_line(rm[0] + 32, rm[1], rm[0] + 32, rm[1] + 64, col)
imgui.end()
def get_node_color(node, iggraph, hovered):
node_color = imgui.get_color_u32_rgba(0,0.5,1,0.5)
if iggraph.is_error(node):
if hovered:
node_color = imgui.get_color_u32_rgba(1,0,0,0.7)
else:
node_color = imgui.get_color_u32_rgba(1,0,0,0.5)
elif iggraph.is_running(node):
if hovered:
node_color = imgui.get_color_u32_rgba(0,1,0,0.7)
else:
node_color = imgui.get_color_u32_rgba(0,1,0,0.5)
elif iggraph.has_run(node):
if hovered:
node_color = imgui.get_color_u32_rgba(0,1,1,0.7)
else:
node_color = imgui.get_color_u32_rgba(0,1,1,0.5)
elif hovered:
node_color = imgui.get_color_u32_rgba(0,0.5,1,0.7)
return node_color
def render_opttrack(self, scale, rectmin):
turns = self.pts['turn']
Nturns = len(turns)
if Nturns < 3:
return
t = np.float32(turns).T
t[1] = -t[1] # invert y
tx = tapetrack.trackexport(t)
s = tapetrack.tracksubdiv(tx, 100)
if self.start_opt:
self.start_opt = False
sscale = np.max(s[:, :2]) - np.min(s[:, :2])
u = s[:, 0] + 1j * s[:, 1]
ye, val, stuff = track_opt.OptimizeTrack(u / sscale,
lanewidth=2 *
self.lanewidth / sscale,
kcurv=self.kcurv,
kdist=self.kdist)
print(u[:30] / sscale)
print(ye[:30])
print(ye[:30] * sscale)
print(self.lanewidth / sscale)
self.opttrack = ye * sscale
if self.opttrack is None:
return
ye = self.opttrack
s *= scale
s[:, 0] += rectmin[0]
s[:, 1] = rectmin[1] - s[:, 1] # uninvert y
s[:, 3] = -s[:, 3]
L = s[:, :2] + (s[:, 2:4].T * ye.T).T
dl = imgui.get_window_draw_list()
magenta = imgui.get_color_u32_rgba(1, 0, 1, 1)
N = len(ye)
for i in range(1 + N):
a = i % N
b = (i + 1) % N
dl.add_line(L[a, 0], L[a, 1], L[b, 0], L[b, 1], magenta)
def render(self, play):
imgui.begin("sim")
dl = imgui.get_window_draw_list()
meterwidth = max(np.max(self.track[:, 0]), np.max(self.lm[:, 0]))
if play:
if imgui.button("pause"):
play = False
else:
if imgui.button("play"):
play = True
# sliders
_, xy = imgui.slider_float2("car xy", self.car.x, -self.car.y, 0,
meterwidth)
self.car.x, self.car.y = xy[0], -xy[1]
_, self.car.theta = imgui.slider_float("car theta", self.car.theta, 0,
2 * np.pi)
imgui.slider_float("car v", self.car.v, 0, 10)
imgui.slider_float2("controls", self.u, self.k, -1, 1)
_, self.lanewidth = imgui.slider_float("lane width", self.lanewidth,
0.1, 2.0)
# render overview
pos = imgui.get_cursor_screen_pos()
siz = imgui.get_content_region_available()
if siz[1] <= 0:
siz = [400, 400]
imgui.invisible_button("overview", siz[0], siz[1])
origin = pos
scale = siz[0] / (meterwidth * 1.1)
conecolor = imgui.get_color_u32_rgba(1, 0.7, 0, 1)
for lm in self.lm:
dl.add_rect_filled(origin[0] + lm[0] * scale - 2,
origin[1] - lm[1] * scale - 2,
origin[0] + lm[0] * scale + 2,
origin[1] - lm[1] * scale + 2, conecolor, 3)
trackcolor = imgui.get_color_u32_rgba(1, 1, 0.3, 0.5)
for i in range(0, len(self.track), 2):
j = (i + 1) % len(self.track)
ti = self.track[i] * scale
tj = self.track[j] * scale
dl.add_line(origin[0] + ti[0], origin[1] - ti[1],
origin[0] + tj[0], origin[1] - tj[1], trackcolor, 1.5)
for i in range(0, len(self.track)):
j = (i + 1) % len(self.track)
ti = self.track[i] * scale
tj = self.track[j] * scale
Li = ti[2:4] * self.lanewidth
Lj = tj[2:4] * self.lanewidth
dl.add_line(origin[0] + ti[0] + Li[0], origin[1] - ti[1] - Li[1],
origin[0] + tj[0] + Lj[0], origin[1] - tj[1] - Lj[1],
trackcolor, 3)
dl.add_line(origin[0] + ti[0] - Li[0], origin[1] - ti[1] + Li[1],
origin[0] + tj[0] - Lj[0], origin[1] - tj[1] + Lj[1],
trackcolor, 3)
mx = scale * self.car.x
my = scale * self.car.y
# draw forward projections
for traj in self.shots:
for i in range(len(traj) - 1):
dl.add_line(origin[0] + traj[i, 0] * scale,
origin[1] - traj[i, 1] * scale,
origin[0] + traj[i + 1, 0] * scale,
origin[1] - traj[i + 1, 1] * scale,
imgui.get_color_u32_rgba(0, 1, 1, 1), 1)
# draw car + velocity
vxy = scale * self.car.v * .1 * \
np.array([np.cos(self.car.theta), np.sin(self.car.theta)])
dl.add_line(origin[0] + mx, origin[1] - my, origin[0] + mx + vxy[0],
origin[1] - my - vxy[1],
imgui.get_color_u32_rgba(0, 1, 0, 1), 1)
imgui.end()
return play
def render_graphs(self):
imgui.begin("graphs")
i = self.i
dl = imgui.get_window_draw_list()
mi = max(0, i - 30 * 3)
temp = self.controlstate[mi:i + 1, 3].copy()
imgui.plot_lines("velocity", temp)
temp = self.controlstate[mi:i + 1, 8].copy()
imgui.plot_lines("target v", temp)
temp = self.controls[mi:i + 1, 0].copy()
imgui.plot_lines("control v", temp)
temp = self.controls[mi:i + 1, 1].copy()
imgui.plot_lines("control steer", temp)
temp = self.controlstate[mi:i + 1, 9].copy()
imgui.plot_lines("target w", temp)
temp = self.controlstate[mi:i + 1, 4].copy()
imgui.plot_lines("yaw rate", temp)
# live variables
maxv = int(np.ceil(np.max(self.controlstate[:, 3]) * 1.1))
imgui.slider_float("wheel v", self.controlstate[i, 3], 0, maxv)
imgui.slider_float("target v", self.controlstate[i, 8], 0, maxv)
lv = 0
if i > 0:
dx = self.controlstate[i, 0] - self.controlstate[i - 1, 0]
dy = self.controlstate[i, 1] - self.controlstate[i - 1, 1]
lv = np.sqrt(dx**2 + dy**2) * 30.0
imgui.slider_float("localized v", lv, 0, maxv)
imgui.slider_float("control motor", self.controls[i, 0] / 127., -1, 1)
imgui.slider_float("control steer", self.controls[i, 1] / 127., -1, 1)
# for yaw rate and curvature, set the limits backwards
# so that turning right is to the right
maxw = int(np.ceil(np.max(np.abs(self.controlstate[:, 4])) * 1.1))
imgui.slider_float("yaw rate", self.controlstate[i, 4], maxw, -maxw)
imgui.slider_float("target w", self.controlstate[i, 9], maxw, -maxw)
v = self.controlstate[i, 3]
if v > 0.5:
k = self.controlstate[i, 4] / v
else:
k = 0
imgui.slider_float("curvature", k, 2, -2)
targetK = self.controlstate[self.i, 7]
imgui.slider_float("target k", targetK, 2, -2)
# render overview
pos = imgui.get_cursor_screen_pos()
siz = imgui.get_content_region_available()
if siz[1] == 0:
siz = [400, 300]
imgui.invisible_button("overview", siz[0], siz[0] * 0.7)
origin = pos
meterwidth = max(np.max(self.track[:, 0]), np.max(self.lm[:, 0]))
scale = siz[0] / (meterwidth * 1.1)
conecolor = imgui.get_color_u32_rgba(1, 0.7, 0, 1)
for lm in self.lm:
dl.add_rect_filled(origin[0] + lm[0] * scale - 2,
origin[1] - lm[1] * scale - 2,
origin[0] + lm[0] * scale + 2,
origin[1] - lm[1] * scale + 2, conecolor, 3)
trackcolor = imgui.get_color_u32_rgba(1, 1, 0.3, 0.5)
for i in range(0, len(self.track), 2):
j = (i + 1) % len(self.track)
ti = self.track[i] * scale
tj = self.track[j] * scale
dl.add_line(origin[0] + ti[0], origin[1] - ti[1],
origin[0] + tj[0], origin[1] - tj[1], trackcolor, 1.5)
particlecolor = imgui.get_color_u32_rgba(1, 1, 1, 0.3)
dl.add_rect(pos[0], pos[1], pos[0] + siz[0], pos[1] + siz[1],
particlecolor, 1)
if 'particles' in self.frame:
ps = self.frame['particles']
for p in ps:
dl.add_rect_filled(origin[0] + p[0] * scale,
origin[1] - p[1] * scale,
origin[0] + p[0] * scale + 1,
origin[1] - p[1] * scale + 1, particlecolor)
# also draw a mean velocity vector
mxy = scale * np.mean(ps[:, :2], axis=0)
vxy = scale * v * .1 * np.array(
[np.mean(np.cos(ps[:, 3])),
np.mean(np.sin(ps[:, 3]))])
dl.add_line(origin[0] + mxy[0], origin[1] - mxy[1],
origin[0] + mxy[0] + vxy[0],
origin[1] - mxy[1] - vxy[1],
imgui.get_color_u32_rgba(0, 1, 0, 1), 1)
else:
x = self.controlstate[self.i, 0]
y = self.controlstate[self.i, 1]
theta = self.controlstate[self.i, 2]
imgui.slider_float("x", x, 0, 20)
imgui.slider_float("y", y, -10, 0)
imgui.slider_float("theta", theta % (2 * np.pi), -np.pi, np.pi)
v = 0.3 * self.controlstate[self.i, 3]
S, C = np.sin(theta), np.cos(theta)
dl.add_rect_filled(origin[0] + x * scale - 3,
origin[1] - y * scale - 3,
origin[0] + scale * x + 3,
origin[1] - scale * y + 3,
imgui.get_color_u32_rgba(0, 1, 0, 1), 1)
dl.add_line(origin[0] + x * scale, origin[1] - y * scale,
origin[0] + scale * (x + v * C),
origin[1] - scale * (y + v * S),
imgui.get_color_u32_rgba(0, 1, 0, 1), 1)
targetaccel = self.controlstate[self.i][12:14] / 9.8
accel = self.carstate[self.i][2]
ox, oy = origin[0] + scale * 3, origin[1] + scale * 9
for i in range(100):
t0 = i * 2 * np.pi / 100
t1 = (i + 1) * 2 * np.pi / 100
dl.add_line(ox + 2 * scale * np.cos(t0),
oy - 2 * scale * np.sin(t0),
ox + 2 * scale * np.cos(t1),
oy - 2 * scale * np.sin(t1),
imgui.get_color_u32_rgba(0.7, 0.7, 0.7, 1), 1)
dl.add_line(ox + scale * np.cos(t0), oy - scale * np.sin(t0),
ox + scale * np.cos(t1), oy - scale * np.sin(t1),
imgui.get_color_u32_rgba(0.7, 0.7, 0.7, 1), 1)
dl.add_line(ox, oy, ox + scale * accel[1], oy - scale * accel[0],
imgui.get_color_u32_rgba(0.3, 1, 0.5, 1), 3)
dl.add_rect(ox - scale * targetaccel[1] - 2,
oy + scale * targetaccel[0] - 2,
ox - scale * targetaccel[1] + 2,
oy + scale * targetaccel[0] + 2,
imgui.get_color_u32_rgba(0.0, 1, 1, 1), 1)
imgui.end()
def render_palette(drawing: Drawing):
global color_editor_open # Need a persistent way to keep track of the popup being closed...
global current_color_page
palette = drawing.palette
fg = palette.foreground
bg = palette.background
fg_color = palette.foreground_color
bg_color = palette.background_color
imgui.begin_child("Palette", border=False, height=460)
# Edit foreground color
if imgui.color_button(f"Foreground (#{fg})", *as_float(fg_color), 0, 30,
30):
io = imgui.get_io()
w, h = io.display_size
imgui.open_popup("Edit foreground color")
imgui.set_next_window_position(w - 115 - 120, 200)
color_editor_open = True
if imgui.begin_popup("Edit foreground color",
flags=(imgui.WINDOW_NO_MOVE
| imgui.WINDOW_NO_SCROLL_WITH_MOUSE)):
done, cancelled, new_color = render_color_editor(
palette.colors[fg], fg_color)
if done and new_color != fg_color:
drawing.change_colors(fg, new_color)
palette.clear_overlay()
elif cancelled:
palette.clear_overlay()
else:
palette.set_overlay(fg, new_color)
imgui.end_popup()
elif color_editor_open:
# The popup was closed by clicking outside, keeping the change (same as OK)
drawing.change_colors(fg, fg_color)
palette.clear_overlay()
color_editor_open = False
imgui.same_line()
imgui.color_button(f"Background (#{bg})", *as_float(bg_color), 0, 30, 30)
max_pages = len(palette.colors) // 64 - 1
imgui.push_item_width(100)
_, current_color_page = imgui.slider_int("Page",
current_color_page,
min_value=0,
max_value=max_pages)
start_color = 64 * current_color_page
imgui.begin_child("Colors", border=False)
imgui.push_style_var(imgui.STYLE_ITEM_SPACING,
(0, 0)) # Make layout tighter
width = int(imgui.get_window_content_region_width()) // 20
imgui.push_style_color(imgui.COLOR_FRAME_BACKGROUND, 0, 0, 0)
colors = palette.colors
# Order the colors by column instead of by row (which is the order we draw them)
for i, c in enumerate(
chain.from_iterable(
zip(range(0, 16), range(16, 32), range(32, 48), range(48,
64)))):
color = colors[start_color + c]
is_foreground = c == fg
is_background = (c == bg) * 2
selection = is_foreground | is_background
color = as_float(color)
if color[3] == 0 or selection:
x, y = imgui.get_cursor_screen_pos()
if imgui.color_button(f"color {i}", *color[:3], 1, 0, 25, 25):
# io = imgui.get_io()
# if io.key_shift:
# if "spread_start" in temp_vars:
# temp_vars["spread_end"] = i
# else:
# temp_vars["spread_start"] = i
# else:
fg = c
if i % width != width - 1:
imgui.same_line()
draw_list = imgui.get_window_draw_list()
if color[3] == 0:
# Mark transparent color
draw_list.add_line(x + 1, y + 1, x + 24, y + 24,
imgui.get_color_u32_rgba(0, 0, 0, 1), 1)
draw_list.add_line(x + 1, y + 2, x + 23, y + 24,
imgui.get_color_u32_rgba(1, 1, 1, 1), 1)
if is_foreground:
# Mark foregroupd color
draw_list.add_rect_filled(x + 2, y + 2, x + 10, y + 10,
imgui.get_color_u32_rgba(1, 1, 1, 1))
draw_list.add_rect(x + 2, y + 2, x + 10, y + 10,
imgui.get_color_u32_rgba(0, 0, 0, 1))
if is_background:
# Mark background color
draw_list.add_rect_filled(x + 15, y + 2, x + 23, y + 10,
imgui.get_color_u32_rgba(0, 0, 0, 1))
draw_list.add_rect(x + 15, y + 2, x + 23, y + 10,
imgui.get_color_u32_rgba(1, 1, 1, 1))
if imgui.core.is_item_clicked(2):
# Right button sets background
bg = c
# Drag and drop (currently does not accomplish anything though)
if imgui.begin_drag_drop_source():
imgui.set_drag_drop_payload('start_index',
c.to_bytes(1, sys.byteorder))
imgui.color_button(f"color {c}", *color[:3], 1, 0, 20, 20)
imgui.end_drag_drop_source()
if imgui.begin_drag_drop_target():
start_index = imgui.accept_drag_drop_payload('start_index')
if start_index is not None:
start_index = int.from_bytes(start_index, sys.byteorder)
io = imgui.get_io()
image_only = io.key_shift
drawing.swap_colors(start_index, c, image_only=image_only)
palette.clear_overlay()
imgui.end_drag_drop_target()
imgui.pop_style_color(1)
imgui.pop_style_var(1)
imgui.end_child()
imgui.end_child()
if imgui.is_item_hovered():
io = imgui.get_io()
delta = int(io.mouse_wheel)
current_color_page = min(max(current_color_page - delta, 0), max_pages)
palette.foreground = fg
palette.background = bg
