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 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 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 draw_map(cur_state):
draw_list = imgui.get_window_draw_list()
vertexes = map_db.get_all_vertexes(cur_state.map_data)
for idx, vertex in enumerate(vertexes):
is_selected = cur_state.mode == Mode.VERTEX and idx == cur_state.cur_vertex
is_hovered = vertex == cur_state.hovered_item and cur_state.hovered_item_type == "Vertex"
draw_map_vert(draw_list, vertex, highlight=(is_selected or is_hovered))
# for wall in cur_state.map_data.walls:
# draw_map_wall(draw_list, wall, highlight = ((cur_state.mode == Mode.LINE and wall==cur_state.cur_wall) or wall == cur_state.hovered_item))
for sect in range(cur_state.map_data.num_sectors):
is_selected = cur_state.mode == Mode.SECTOR and sect == cur_state.cur_sector
is_hovered = cur_state.hovered_item == sect and cur_state.hovered_item_type == "Sector"
this_sectors_group = map_db.get_sector_constant(
cur_state.map_data, sect, map_db.SECT_GROUP_IDX)
is_group_hovered = cur_state.hovered_item_type == "Sector Group" and cur_state.hovered_item == this_sectors_group
#is_hovered = cur_state.hovered_item == get_sector
draw_sector(draw_list,
sect,
highlight=is_selected or is_hovered or is_group_hovered)
if (cur_state.mode == Mode.SECTOR and cur_state.cur_sector != -1):
draw_sector(draw_list, cur_state.cur_sector, highlight=True)
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 _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(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):
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 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 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 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 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 line(x0, y0, x1, y1, color, thickness=1, tf=None):
""" Line connecting two points. """
if tf is not None:
[x0, y0], [x1, y1] = tf.transform(np.array([[x0, y0], [x1, y1]]))
draw_list = imgui.get_window_draw_list()
col = color_to_rgba(color)
while True:
draw_list.add_line(x0, y0, x1, y1, col, thickness)
yield
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 polygon(points, color, tf=None):
""" Filled polygon. Points must form a convex area.
`points` is a list of (x, y) tuples, or a NumPy array of equivalent shape.
"""
points = prepare_polyline_points(points, tf)
draw_list = imgui.get_window_draw_list()
col = color_to_rgba(color)
while True:
draw_list.add_convex_poly_filled(points, col)
yield
def polyline(points, color, closed=False, thickness=1, tf=None):
""" Polygonal line or a closed polygon.
`points` is a list of (x, y) tuples, or a NumPy array of equivalent shape.
"""
points = prepare_polyline_points(points, tf)
draw_list = imgui.get_window_draw_list()
col = color_to_rgba(color)
while True:
draw_list.add_polyline(points, col, closed, thickness)
yield
def draw(self):
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()
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 rect(x0, y0, x1, y1, color, thickness=1, rounding=0, tf=None):
""" Straight non-filled rectangle specified by its two corners. """
if tf is not None:
[x0, y0], [x1, y1] = tf.transform(np.array([[x0, y0], [x1, y1]]))
# Avoid issues with disappearing lines on very large rectangles
x0, x1 = np.clip([x0, x1], -8192, 8192)
y0, y1 = np.clip([y0, y1], -8192, 8192)
draw_list = imgui.get_window_draw_list()
col = color_to_rgba(color)
while True:
draw_list.add_rect(x0, y0, x1, y1, col, rounding,
15 if rounding else 0, thickness)
yield
def text(string, x, y, color, tf=None):
""" Text, using the default font and font size.
This is a raw drawing function. Use `concur.widgets.text` instead if you want a text widget.
"""
if tf is not None:
x, y = np.matmul(tf.c2s, [x, y, 1])
col = color_to_rgba(color)
while True:
# Text was hanging the application if too far away
if -8192 < x < 8192 and -8192 < y < 8192:
draw_list = imgui.get_window_draw_list()
draw_list.add_text(x, y, col, string)
yield
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 image(tex_id, x, y, width, height, uv_a=(0, 0), uv_b=(1, 1), tf=None):
""" Draw an image with the given origin (x, y), width and height.
This is a raw drawing function. Use `concur.extra_widgets.image.image` instead
if you want an image widget. Note that OpenGL textures may be rendered incorrectly
if width or height isn't divisible by 4.
"""
p1, p2 = [x, y], [x + width, y + height]
if tf is not None:
p1, p2 = tf.transform(np.array([p1, p2]))
draw_list = imgui.get_window_draw_list()
while True:
draw_list.add_image(tex_id, tuple(p1), tuple(p2), uv_a, uv_b)
yield
def polygons(points, color, tf=None):
""" Multiple filled polygons with the same length and color.
Calling this function is more efficient than calling `polygon` multiple times, because all the data is given
to the C++ back-end in one Python call, and because transformation is vectorized.
`points` is a NumPy array with shape `(n, m, 2)`, where `n` is the number of polygons, and `m` is the number of points
in each polyline.
"""
if tf is not None:
points = tf.transform(points.reshape(-1, 2)).reshape(points.shape)
draw_list = imgui.get_window_draw_list()
col = color_to_rgba(color)
while True:
draw_list.add_convex_polys_filled(points, col)
yield
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 circle(cx, cy, radius, color, thickness=1, num_segments=16, tf=None):
""" Circle specified by its center and radius. """
if tf is not None:
assert np.allclose(np.abs(tf.c2s[0, 0]), np.abs(tf.c2s[1, 1])), \
"`tf` must be aspect ratio preserving to draw circles. Use `ellipse` instead, if it isn't the case."
[cx, cy], radius = np.matmul(tf.c2s,
[cx, cy, 1]), radius * tf.c2s[0, 0]
draw_list = imgui.get_window_draw_list()
col = color_to_rgba(color)
while True:
draw_list.add_circle(cx,
cy,
radius,
col,
num_segments=num_segments,
thickness=thickness)
yield
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("Image example")
draw_list = imgui.get_window_draw_list()
#imgui.image(self.texture.glo, *self.texture.size)
#draw_list.add_image(self.texture_id, (0, 0), (self.width, self.height))
draw_list.add_image(self.texture.glo, (0, 0), self.texture.size)
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 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 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 polylines(points, color, closed=False, thickness=1, tf=None):
""" Multiple polygonal lines with the same length and parameters.
Calling this function is more efficient than calling `polyline` multiple times, because all the data is given
to the C++ back-end in one Python call, and because transformation is vectorized.
`points` is a NumPy array with shape `(n, m, 2)`, where `n` is the number of polylines, and `m` is the number of points
in each polyline.
"""
if len(points) == 0:
while True:
yield
if tf is not None:
points = tf.transform(points.reshape(-1, 2)).reshape(points.shape)
draw_list = imgui.get_window_draw_list()
col = color_to_rgba(color)
while True:
draw_list.add_polylines(points, col, closed, thickness)
yield
