def __current_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(5, 393 + 128),
bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(345, 110), bimpy.Condition.Once)
bimpy.begin("Current",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Current")
bimpy.pop_font()
bimpy.separator()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(25, 0)
bimpy.text("{:.2f}".format(self.data.voltage).rjust(6, "0"))
bimpy.pop_font()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.same_line(215, 0)
bimpy.text("Amp")
bimpy.pop_font()
bimpy.end()
def __voltage_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(5, 278 + 128),
bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(345, 110), bimpy.Condition.Once)
bimpy.begin("Voltage",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Voltage")
bimpy.pop_font()
bimpy.separator()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(25, 0)
if self.data.voltage >= 0:
bimpy.text("{:.2f}".format(self.data.voltage).rjust(6, "0"))
else:
bimpy.text("-" + "{:.2f}".format(self.data.voltage).rjust(5, "0"))
bimpy.pop_font()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.same_line(220, 0)
bimpy.text("Volt")
bimpy.pop_font()
bimpy.end()
def __distance_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(5, 120 + 128),
bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(345, 110), bimpy.Condition.Once)
bimpy.begin("Distance",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Distance Traveled")
bimpy.pop_font()
bimpy.separator()
if self.data.distance <= 1.1:
distance_formatted_data = str(int(self.data.distance * 1000))
distance_formatted_data = distance_formatted_data.rjust(4, "0")
scalar = "m"
else:
distance_formatted_data = "{:.2f}".format(self.data.distance)
distance_formatted_data = distance_formatted_data.rjust(6, "0")
scalar = "Km"
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(38, -1)
bimpy.text(distance_formatted_data)
bimpy.same_line(245, 0)
bimpy.text(scalar)
bimpy.pop_font()
bimpy.end()
def __rpm_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(705, 278 + 128),
bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(305, 225), bimpy.Condition.Once)
bimpy.begin("RPM",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "RPM")
bimpy.pop_font()
bimpy.separator()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(25, 0)
bimpy.text(str(int(self.data.rpm)).rjust(4, "0"))
bimpy.pop_font()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.same_line(175, 0)
bimpy.text("RPM")
bimpy.pop_font()
self.rpm_datas.append(self.data.rpm)
self.rpm_datas.pop(0)
self.rpm_datas.reverse()
bimpy.plot_lines("", self.rpm_datas, graph_size=bimpy.Vec2(288, 112))
self.rpm_datas.reverse()
bimpy.end()
def __calories_burtn_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(355, 5 + 128),
bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(345, 110), bimpy.Condition.Once)
bimpy.begin("Calories Burnt",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Calories Burnt")
bimpy.pop_font()
bimpy.separator()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(25, 0)
if self.data.calories_burned >= 0:
bimpy.text("{:.2f}".format(self.data.calories_burned).rjust(
7, "0"))
else:
bimpy.text("0.00".rjust(7, "0"))
bimpy.pop_font()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.same_line(250, 0)
bimpy.text("cal")
bimpy.pop_font()
bimpy.end()
def __speed_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(355, 120 + 128),
bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(345, 110), bimpy.Condition.Once)
bimpy.begin("Speed",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Speed")
bimpy.pop_font()
bimpy.separator()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(25, 0)
bimpy.text(str(int(self.data.speed[0])).rjust(4, " "))
bimpy.pop_font()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.same_line(200, 0)
bimpy.text("Km/H")
bimpy.pop_font()
bimpy.end()
def main():
global CTX
ctx = bimpy.Context()
ctx.init(1200, 1200, "Image")
with ctx:
bimpy.themes.set_light_theme()
socket_thread = threading.Thread(target = thread_socket_func, args = (8883, ))
socket_thread.start()
message_thread = threading.Thread(target = message_thread_func)
message_thread.start()
previous_n_points = 0
clear_flag = False
while not ctx.should_close():
with ctx:
bimpy.set_next_window_pos(bimpy.Vec2(120, 120), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(400, 400), bimpy.Condition.Once)
bimpy.begin("Window #1")
bimpy.text("This is text!")
if bimpy.button("Send A Lot Of Messages"):
temp_messages = [make_message_text("log", "Message #" + str(i)) for i in range(560)]
send_messages(CTX.message_pipeline, temp_messages)
if bimpy.button("Send A Lot Of Random Points"):
temp_messages = [make_message_point("point", (random.randrange(400 + i), random.randrange(400 + i))) for i in range(20)]
send_messages(CTX.message_pipeline, temp_messages)
if bimpy.button("Clear Flag"):
clear_flag = not clear_flag
bimpy.text("Text from events:\n%s" % (CTX.data.text))
bimpy.end()
draw_window_drawing(ctx, 400, 400, "Sample Drawing", CTX.data.points)
log("Exited rendering thread")
log("Sending exit to message_thread")
send_message_text(CTX.message_pipeline, "exit", "")
log("Waiting for message_thread")
message_thread.join()
CTX.server_socket_running = False
if CTX.server_socket:
for c, info in CTX.server_socket.connections:
c.send(b'exit')
log("Waiting for socket_thread")
socket_thread.join()
log("Bye")
def begin_root(name="root", menu=False):
bp.set_next_window_pos(bp.Vec2(0, 0))
bp.set_next_window_size(bp.io.display_size)
bp.push_style_var(bp.Style.WindowRounding, 0)
flags = bp.WindowFlags.NoDecoration | bp.WindowFlags.NoMove
if menu:
flags = flags | bp.WindowFlags.MenuBar
bp.begin("name", flags=flags)
bp.pop_style_var()
def __separator_name_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(5, 90), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(1005, 38), bimpy.Condition.Once)
bimpy.begin("Separator Name",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.separator()
bimpy.text("")
bimpy.separator()
bimpy.end()
def main():
selected_compiler = bimpy.Int()
ctx = bimpy.Context()
ctx.init(WIDTH, HEIGHT, "Virtual enviroment manager")
environments = getAvailableEnviroments()
compilers_list = list(data.compilers.keys())
show_new_env_menu = False
while (not ctx.should_close()):
with ctx:
bimpy.set_next_window_pos(bimpy.Vec2(0, 0), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(WIDTH, HEIGHT),
bimpy.Condition.Once)
bimpy.begin("Enviroments",bimpy.Bool(True), \
bimpy.WindowFlags.NoCollapse and bimpy.WindowFlags.NoResize)
bimpy.text(sys.version)
bimpy.columns(2)
for enviroment in environments:
if bimpy.button(enviroment):
compiler = list(data.compilers.values())[
selected_compiler.
value] if selected_compiler.value != 0 else ""
subprocess.call(
['start', environments[enviroment], compiler],
shell=True)
bimpy.next_column()
if bimpy.button("O##" + enviroment):
subprocess.Popen(r'explorer /select,' +
os.path.dirname(environments[enviroment]))
#os.startfile(os.path.realpath(os.path.dirname(environments[enviroment])))
bimpy.next_column()
bimpy.columns(1)
if bimpy.combo("Compiler", selected_compiler, compilers_list):
pass
# if bimpy.button("Add new enviroment"):
# new_env_ctx = BimpyContext(WIDTH, HEIGHT, "New enviroment menu")
# while(not new_env_ctx.ctx.should_close()):
# with new_env_ctx.ctx:
# bimpy.begin("dsad")
# bimpy.text("d")
# bimpy.end()
# if bimpy.button("Create new enviroment"):
bimpy.end()
def __heart_rate_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(705, 5 + 128),
bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(305, 225), bimpy.Condition.Once)
bimpy.begin("Heart Rate",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Heart Rate")
bimpy.pop_font()
bimpy.separator()
bimpy.text("")
bimpy.same_line(30, -1)
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text(str(int(self.data.heart_rate)).rjust(3, "0"))
bimpy.pop_font()
bimpy.same_line(140, 20)
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text("BPM")
bimpy.pop_font()
if (time.time() -
self.heart_rate_start_monitor) >= (self.data.heart_rate / 60):
self.heart_rate_data.append(-0.7)
self.heart_rate_data.append(1)
self.heart_rate_start_monitor = time.time()
self.heart_rate_data.pop(0)
else:
self.heart_rate_data.append(0)
self.heart_rate_data.pop(0)
self.heart_rate_data.reverse()
bimpy.plot_lines("",
self.heart_rate_data,
graph_size=bimpy.Vec2(288, 112),
scale_min=-1.0,
scale_max=1.3)
self.heart_rate_data.reverse()
bimpy.end()
def render(self, config_server):
if self.ctx.should_close():
return 0
self.ctx.new_frame()
bimpy.set_next_window_pos(bimpy.Vec2(0, 0), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(self.width, self.height),
bimpy.Condition.Once)
bimpy.begin("",
flags=bimpy.WindowFlags.NoResize
| bimpy.WindowFlags.NoTitleBar | bimpy.WindowFlags.NoMove)
self.draw_gui(config_server)
bimpy.end()
self.ctx.render()
return 1
def __age_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(900, 5), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(110, 80), bimpy.Condition.Once)
bimpy.begin("Age",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Age")
bimpy.pop_font()
bimpy.separator()
bimpy.push_font(self.fonts.fonts[16]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(38, 0)
bimpy.text(str(self.data.age))
bimpy.pop_font()
bimpy.end()
def __gender_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(729, 5), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(166, 80), bimpy.Condition.Once)
bimpy.begin("Gender",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Gender")
bimpy.pop_font()
bimpy.separator()
bimpy.push_font(self.fonts.fonts[16]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(38, 0)
bimpy.text("Female" if self.data.gender else "Male")
bimpy.pop_font()
bimpy.end()
def draw_window_drawing(ctx, w, h, name, points):
bimpy.set_next_window_pos(bimpy.Vec2(w + 20, h + 20), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(w, h), bimpy.Condition.Once)
bimpy.begin(name)
window_zero = bimpy.get_window_pos() + bimpy.Vec2(100 + temp_separation_test.value, 100 + temp_separation_test.value)
window_one = bimpy.get_window_pos() + bimpy.Vec2(w - 100 - temp_separation_test.value, h - 100 - temp_separation_test.value)
bimpy.add_circle_filled(window_zero, 5.0, 0xFF000000 + 0xc88200, 100)
bimpy.add_circle_filled(window_one, 5.0, 0xFF000000 + 0x4bb43c, 100)
for x,y in points:
point = bimpy.get_window_pos() + bimpy.Vec2(x, y)
bimpy.add_circle_filled(point, 5.0, 0xFF000000 + 0x4bb43c, 100)
bimpy.slider_float("separation", temp_separation_test, 0.0, 100.0)
bimpy.end()
def __time_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(5, 5 + 128), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(345, 110), bimpy.Condition.Once)
bimpy.begin("Time Elapsed",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Time Elapsed")
bimpy.pop_font()
bimpy.separator()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(38, 0)
bimpy.text(
str(datetime.timedelta(seconds=self.data.exercize_time))[:-4])
bimpy.pop_font()
bimpy.end()
def render(self):
# display_size = bimpy.get_display_size()
window_pos = bimpy.Vec2(self._distance, self._distance)
window_pos_pivot = bimpy.Vec2(0.0, 0.0)
bimpy.set_next_window_pos(window_pos, bimpy.Condition.FirstUseEver, window_pos_pivot)
bimpy.set_next_window_bg_alpha(0.35)
flags = bimpy.WindowFlags.NoDecoration \
| bimpy.WindowFlags.AlwaysAutoResize \
| bimpy.WindowFlags.NoSavedSettings \
| bimpy.WindowFlags.NoFocusOnAppearing \
| bimpy.WindowFlags.NoFocusOnAppearing \
| bimpy.WindowFlags.NoNav
if bimpy.begin("logging overlay##logging_tools", flags=flags):
if bimpy.is_mouse_pos_valid(None):
mouse_pos = bimpy.get_mouse_pos()
bimpy.text("Mouse Pos: ({:.1f},{:.1f})".format(mouse_pos.x, mouse_pos.y))
else:
bimpy.text("Mouse Pos: <invalid>")
bimpy.end()
def __power_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(355, 278 + 128),
bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(345, 225), bimpy.Condition.Once)
bimpy.begin("Power",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Power")
bimpy.pop_font()
bimpy.separator()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.text("")
bimpy.same_line(25, 0)
bimpy.text("{:.2f}".format(self.data.power).rjust(6, "0"))
bimpy.pop_font()
bimpy.push_font(self.fonts.fonts[44]["ext_bold_ital"])
bimpy.same_line(212, 0)
bimpy.text("Watts")
bimpy.pop_font()
self.power_datas.append(self.data.power)
self.power_datas.pop(0)
self.power_datas.reverse()
bimpy.plot_lines("",
self.power_datas,
graph_size=bimpy.Vec2(329, 112),
scale_min=-1.0,
scale_max=500.0)
self.power_datas.reverse()
bimpy.end()
### Then run that function on a second thread
## AKA
# import threading
# def fetchTempFunction():
# return to array and use the array to fill in the values
# cool_thread = threading.Thread(target = fetchTempFunction())
# cool_thread.start()
if __name__ == "__main__":
while (not ctx.should_close()):
with ctx:
w.Sensor()
# intro window
b.set_next_window_pos(b.Vec2(12, 15), b.Condition.Once)
b.set_next_window_size(b.Vec2(765, 80), b.Condition.Once)
b.begin("Hardware-Rating")
b.text("Welcome to Hardware-Rating,")
b.same_line()
b.text(realUser)
b.text(
"Below are your listed computer components and any other useful information per device."
)
# CPU window
b.set_next_window_pos(b.Vec2(12, 100), b.Condition.Once)
b.set_next_window_size(b.Vec2(435, 325), b.Condition.Once)
b.begin("CPU")
def render(self, ctx, windows_info):
pos = bimpy.Vec2(conf.margin, conf.margin)
size_min = bimpy.Vec2(conf.min_file_browser_width,
ctx.height() - 2 * conf.margin)
size_max = bimpy.Vec2(conf.max_file_browser_width,
ctx.height() - 2 * conf.margin)
bimpy.set_next_window_pos(pos, bimpy.Condition.Once)
bimpy.set_next_window_size_constraints(size_min, size_max)
bimpy.begin(LANG.file_brewswer_ui_title, bimpy.Bool(True),
bimpy.WindowFlags.NoCollapse | bimpy.WindowFlags.NoMove)
###########UI###########
if bimpy.button(LANG.file_brewswer_ui_refresh) == True:
self.fb.refresh_file_list()
bimpy.same_line()
if bimpy.button(LANG.about) == True:
bimpy.open_popup(LANG.about)
# call render about ui
# print(dir(windows_info['about_ui']))
windows_info['about_ui']['self'].about()
for idx, f_name in enumerate(self.fb.file_list):
# print(self.selected.value)
if bimpy.selectable(
f_name.split('\\')[-1], self.selected.value == idx):
self.selected.value = idx
if self.selected.value != -1 and self.selected.value != self.preidx:
self.preidx = self.selected.value
windows_info['image_shower_ui']['self'].update_pic(f_name)
windows_info['meta_info_ui']['self'].update_meta_info(
f_name)
# progress bar
if not self.fb.q.empty():
self.process = self.fb.q.get()
f, d = self.process[-2], self.process[-1]
# update if new
if d != {}:
self.fb.pp.yolo_res[f] = d
self.process = (self.process[0] + 1, self.process[1])
if self.process[0] == self.process[1]:
with open('yolo_res', 'wb') as f:
pickle.dump(self.fb.pp.yolo_res, f)
# build retrieval index
windows_info['retrival_ui']['self'].init = False
sz = bimpy.get_window_size()
bimpy.set_cursor_pos(bimpy.Vec2(conf.margin, sz.y - conf.margin * 2))
bimpy.push_item_width(sz.x - conf.margin * 3 - 60)
process = self.process
bimpy.progress_bar(process[0] / float(process[1]),
bimpy.Vec2(0.0, 0.0),
"{}/{}".format(process[0], process[1]))
bimpy.same_line()
if bimpy.button(LANG.reindex) == True and process[0] == process[1]:
self.fb.refresh()
########################
t = {
'x': bimpy.get_window_pos().x,
'y': bimpy.get_window_pos().y,
'w': bimpy.get_window_size().x,
'h': bimpy.get_window_size().y,
'self': self,
}
bimpy.end()
return t
def render(self):
bimpy.set_next_window_pos(bimpy.Vec2(40, 30), bimpy.Condition.FirstUseEver)
bimpy.set_next_window_size(bimpy.Vec2(681, 700), bimpy.Condition.FirstUseEver)
if not bimpy.begin('canvas window##canvas'):
bimpy.end()
return
if not bimpy.begin_child('canvas##canvas', border=False):
bimpy.end_child()
return
canvas_pos = bimpy.get_cursor_screen_pos()
canvas_size = bimpy.get_content_region_avail()
bimpy.invisible_button('canvas button##canvas', canvas_size)
# mouse wheel scroll zoom
if bimpy.is_item_hovered():
mouse_wheel_delta = bimpy.get_mouse_wheel_delta()
if mouse_wheel_delta < 0:
self._canvas_scale_ratio = min(self._canvas_scale_ratio + self._canvas_scale_ratio_delta,
self._canvas_scale_ratio_max)
if mouse_wheel_delta > 0:
self._canvas_scale_ratio = max(self._canvas_scale_ratio - self._canvas_scale_ratio_delta,
self._canvas_scale_ratio_min)
shift_ratio = 0.5 * (self._canvas_scale_ratio - 1) / self._canvas_scale_ratio
origin = bimpy.Vec2(
canvas_pos.x + canvas_size.x * shift_ratio,
canvas_pos.y + canvas_size.y * (1 - shift_ratio)
)
scale = min(canvas_size.x, canvas_size.y) / self._canvas_scale_ratio
mouse_pos = bimpy.get_mouse_pos()
relative_pos = Point(
(mouse_pos.x - origin.x) / scale,
(mouse_pos.y - origin.y) / -scale,
)
# user line draw
if self.user_line_draw_component.if_is_drawing():
# print('is_drawing')
if bimpy.is_item_hovered():
if not self._drawing_start and bimpy.is_mouse_clicked(0, False):
self._drawing_start = True
self.user_line_draw_component.set_drawing_start_point(relative_pos)
if self._drawing_start:
mouse_down = bimpy.is_mouse_down(0)
self._drawing_start = mouse_down
self.user_line_draw_component.set_drawing_end_point(relative_pos, not mouse_down)
# user convex draw
if self.user_convex_draw_component.if_is_drawing():
if bimpy.is_item_hovered():
if bimpy.is_mouse_double_clicked(0):
self.user_convex_draw_component.set_user_done()
elif bimpy.is_mouse_clicked(0, False):
self.user_convex_draw_component.set_user_add_point(relative_pos)
if bimpy.is_mouse_double_clicked(1):
self.user_convex_draw_component.set_user_cancel()
elif bimpy.is_mouse_clicked(1, False):
self.user_convex_draw_component.set_user_pop_point()
# draw background
bimpy.add_rect_filled(
canvas_pos,
bimpy.Vec2(canvas_pos.x + canvas_size.x, canvas_size.y + canvas_size.y),
im_col32(200, 200, 200),
)
bimpy.add_rect(
bimpy.Vec2(origin.x, -scale + origin.y),
bimpy.Vec2(scale + origin.x, origin.y),
im_col32(0, 0, 0),
)
# draw others
if self.user_convex_draw_component.if_is_drawing():
self.user_convex_draw_component.render(origin, scale)
else:
self.convex_draw_component.render(origin, scale)
self.lines_draw_component.render(origin, scale)
self.user_line_draw_component.render(origin, scale)
# show mouse pos
if bimpy.is_mouse_pos_valid(None) and bimpy.is_item_hovered():
bimpy.add_text_simple(
bimpy.Vec2(canvas_pos.x + 15, canvas_pos.y + 10),
im_col32(0, 0, 0),
'x: {:.6f} y: {:.6f}'.format(relative_pos.x, relative_pos.y),
)
# show drawing state
if self.user_line_draw_component.if_is_drawing():
bimpy.add_text_simple(
bimpy.Vec2(canvas_pos.x + 15, canvas_pos.y + 30),
im_col32(0, 0, 0),
'drawing line {}'.format(self.user_line_draw_component.get_waitting_draw_line_index()),
)
bimpy.end_child()
bimpy.end()
def __buttons_window(self):
bimpy.set_next_window_pos(bimpy.Vec2(5, 635), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(1005, 128), bimpy.Condition.Once)
bimpy.begin("Exercise Control",
flags=bimpy.WindowFlags(4) | bimpy.WindowFlags(1)
| bimpy.WindowFlags(2))
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text_colored(bimpy.Vec4(1, 0, 0, 1), "Controls")
bimpy.separator()
bimpy.pop_font()
bimpy.push_font(self.fonts.fonts[16]["cond"])
bimpy.text("")
bimpy.same_line(0, 150)
if self.pause_button_state == 1:
bimpy.push_style_color(bimpy.Colors(0), bimpy.Vec4(0, 0, 0, 1))
bimpy.push_style_color(bimpy.Colors(21),
bimpy.Vec4(0.8, 0.8, 0, 1))
bimpy.push_style_color(bimpy.Colors(22), bimpy.Vec4(1, 1, 0, 1))
bimpy.push_style_color(bimpy.Colors(23),
bimpy.Vec4(0.5, 0.5, 0, 1))
pause_button_text = "Pause Exercise"
elif self.pause_button_state == 0:
bimpy.push_style_color(bimpy.Colors(0), bimpy.Vec4(0, 0, 0, 1))
bimpy.push_style_color(bimpy.Colors(21),
bimpy.Vec4(0.0, 0.8, 0.0, 1))
bimpy.push_style_color(bimpy.Colors(22),
bimpy.Vec4(0.0, 1, 0.0, 1))
bimpy.push_style_color(bimpy.Colors(23),
bimpy.Vec4(0.0, 0.5, 0.0, 1))
pause_button_text = "Resume Exercise"
elif self.pause_button_state == -1:
bimpy.push_style_color(bimpy.Colors(0), bimpy.Vec4(0, 0, 0, 1))
bimpy.push_style_color(bimpy.Colors(21),
bimpy.Vec4(0.4, 0.4, 0.4, 1))
bimpy.push_style_color(bimpy.Colors(22),
bimpy.Vec4(0.4, 0.4, 0.4, 1))
bimpy.push_style_color(bimpy.Colors(23),
bimpy.Vec4(0.4, 0.4, 0.4, 1))
pause_button_text = "------ -------"
if bimpy.button(pause_button_text, bimpy.Vec2(250, 75)):
if self.pause_button_state == 1:
self.pause_button_state = 0
self.data.is_exercising = False
elif self.pause_button_state == 0:
self.pause_button_state = 1
self.data.is_exercising = True
bimpy.pop_style_color()
bimpy.pop_style_color()
bimpy.pop_style_color()
bimpy.pop_style_color()
bimpy.same_line(450, 150)
if self.stop_button_enabled:
bimpy.push_style_color(bimpy.Colors(0), bimpy.Vec4(0, 0, 0, 1))
bimpy.push_style_color(bimpy.Colors(21), bimpy.Vec4(0.8, 0, 0, 1))
bimpy.push_style_color(bimpy.Colors(22), bimpy.Vec4(1, 0, 0, 1))
bimpy.push_style_color(bimpy.Colors(23), bimpy.Vec4(0.5, 0, 0, 1))
else:
bimpy.push_style_color(bimpy.Colors(0), bimpy.Vec4(0, 0, 0, 1))
bimpy.push_style_color(bimpy.Colors(21),
bimpy.Vec4(0.4, 0.4, 0.4, 1))
bimpy.push_style_color(bimpy.Colors(22),
bimpy.Vec4(0.4, 0.4, 0.4, 1))
bimpy.push_style_color(bimpy.Colors(23),
bimpy.Vec4(0.4, 0.4, 0.4, 1))
self.pause_button_state = -1
if bimpy.button("Stop Exercise", bimpy.Vec2(250, 75)):
self.data.is_exercising = False
self.stop_button_enabled = False
bimpy.pop_style_color()
bimpy.pop_style_color()
bimpy.pop_style_color()
bimpy.pop_style_color()
bimpy.pop_font()
bimpy.end()
def render(self, ctx, windows_info):
# calculate autoly
self.pos = bimpy.Vec2(
windows_info['file_brewswer_ui']['x'] +
windows_info['file_brewswer_ui']['w'] + conf.margin, conf.margin)
self.size = bimpy.Vec2(
ctx.width() - self.pos.x - conf.margin,
ctx.height() - 3 * conf.margin - conf.meta_info_height)
bimpy.set_next_window_pos(self.pos, bimpy.Condition.Always)
bimpy.set_next_window_size(self.size, bimpy.Condition.Always)
bimpy.begin(
LANG.image_shower_ui_title, bimpy.Bool(True),
bimpy.WindowFlags.NoCollapse | bimpy.WindowFlags.NoMove
| bimpy.WindowFlags.NoResize
| bimpy.WindowFlags.HorizontalScrollbar)
###########UI###########
# modal part
if self.im is not None:
bimpy.set_cursor_pos(bimpy.Vec2(0.0, conf.margin * 3))
bimpy.image(self.im)
# if image is loaded
if self.labels is not None:
for i, label in enumerate(self.labels):
color = self.COLORS[self.classes.index(label)]
# print((self.bbox[i][0], self.bbox[i][1] - 10))
# show on the left bottom of the picture
bimpy.set_cursor_pos(
bimpy.Vec2(self.bbox[i][0] + 10, self.bbox[i][3] + 10))
# set style
bimpy.push_id_int(i)
if conf.show_yolo_confience:
bimpy.button(
label + ' ' +
str(format(self.confidence[i] * 100, '.2f')) + '%')
else:
bimpy.button(label)
if bimpy.is_item_hovered(i):
s = "{} ({})\n{}"
label = label[0].upper() + label[1:]
s = s.format(
label,
str(format(self.confidence[i] * 100, '.2f')) + '%',
LANG.click_to_view_more)
bimpy.set_tooltip(s)
if bimpy.is_item_active():
self.select_label = label
bimpy.pop_id()
# bimpy.set_cursor_pos(bimpy.Vec2(conf.margin, self.size.y - conf.margin * 2))
bimpy.set_cursor_pos(bimpy.Vec2(conf.margin, conf.margin * 1.5))
if bimpy.button(LANG.smart_analyse) == True:
self.object_detection()
bimpy.same_line()
bimpy.checkbox(LANG.auto, self.auto)
### Resize ###
bimpy.same_line()
bimpy.push_item_width(150)
bimpy.drag_float(LANG.drag, self.scale, 1.0, 10, 1000)
bimpy.pop_item_width()
if abs(self.last_scale - self.scale.value) > 4.:
xx = self.size.x * self.scale.value / 100.
yy = (self.size.y - 45 - 40) * self.scale.value / 100.
im = self.i_s.resize(self.raw_im, xx, yy)
self.now_im = im
self.set_im(im)
# set to save computation
self.last_scale = self.scale.value
# if selected obj
if self.select_label != '':
# print(self.select_label)
windows_info['retrival_ui'][
'self'].select_label = self.select_label
bimpy.open_popup('{}: {}'.format(LANG.retrieve, self.select_label))
# reset
self.select_label = ''
windows_info['retrival_ui']['self'].retrival()
########################
t = {
'x': bimpy.get_window_pos().x,
'y': bimpy.get_window_pos().y,
'w': bimpy.get_window_size().x,
'h': bimpy.get_window_size().y,
'self': self,
}
bimpy.end()
return t
def main():
parser = ArgumentParser(description="Preview animations")
parser.add_argument("--version",
action="version",
version="%(prog)s " + __version__)
parser.add_argument("--width",
dest="width",
type=int,
default=DEF_WIDTH,
help="frame width (default: %s)" % DEF_WIDTH)
parser.add_argument("--height",
dest="height",
type=int,
default=DEF_HEIGHT,
help="frame height (default: %s)" % DEF_HEIGHT)
parser.add_argument("--scale",
dest="scale",
type=int,
default=DEF_SCALE,
help="scale preview (default: %s)" % DEF_SCALE)
parser.add_argument("--double-w",
dest="dw",
action="store_true",
help="double width for 2:1")
parser.add_argument(
"--mtime",
dest="mtime",
type=int,
default=DEF_MTIME,
help="seconds between checks for changes (default: %s)" % DEF_MTIME)
parser.add_argument("image", help="image to convert")
args = parser.parse_args()
def load_image(filename):
@with_retry
def load():
return Image.open(filename).convert("RGB")
try:
image = load()
except IOError:
parser.error("failed to open the image")
(w, h) = image.size
if w % args.width or h % args.height:
parser.error("%s size is not multiple of tile size (%s, %s)" %
(filename, args.width, args.height))
frames = []
for y in range(0, h, args.height):
for x in range(0, w, args.width):
frames.append((x, y, x + args.width, y + args.height))
return image, frames
image, frames = load_image(args.image)
frame_list = list(range(len(frames)))
def scale_image(scale, frameno):
scale_w = scale if not args.dw else scale * 2
current = image.resize((args.width * scale_w, args.height * scale),
box=frames[frame_list[frameno]],
resample=0)
return bimpy.Image(current)
ctx = bimpy.Context()
ctx.init(320, 420, "Preview animation")
orig = bimpy.Image(image)
scale = bimpy.Int(args.scale)
fps = bimpy.Int(args.scale)
frame_list_str = bimpy.String(','.join(map(str, frame_list)))
im = scale_image(scale.value, 0)
cur_frame = 0
paused = False
start_time = time()
check_mtime = time()
last_mtime = os.stat(args.image).st_mtime
while (not ctx.should_close()):
if time() - check_mtime > args.mtime:
if os.stat(args.image).st_mtime != last_mtime:
last_mtime = os.stat(args.image).st_mtime
image, frames = load_image(args.image)
cur_frame = 0
start_time = time()
if any([f >= len(frames) for f in frame_list]):
frame_list = list(range(len(frames)))
frame_list_str = bimpy.String(','.join(map(
str, frame_list)))
ctx.new_frame()
bimpy.set_next_window_pos(bimpy.Vec2(10, 10), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(300, 400), bimpy.Condition.Once)
bimpy.begin("Image: %s" % args.image)
if not paused:
if time() - start_time >= 1. / fps.value:
start_time = time()
cur_frame += 1
if cur_frame == len(frame_list):
cur_frame = 0
im = scale_image(scale.value, cur_frame)
bimpy.image(orig)
bimpy.image(im)
bimpy.text("Frame: %02d" % frame_list[cur_frame])
if bimpy.slider_int("Scale", scale, 1, 20):
im = scale_image(scale.value, cur_frame)
if bimpy.slider_int("FPS", fps, 1, 30):
start_time = time()
cur_frame = 0
if bimpy.input_text("Frames", frame_list_str, 64,
bimpy.InputTextFlags.EnterReturnsTrue):
try:
new_frame_list = [
int(i.strip()) for i in frame_list_str.value.split(",")
]
frame_list = new_frame_list
start_time = time()
cur_frame = 0
except Exception as ex:
print("Error parsing frame list: %s" % ex)
if bimpy.button("Play" if paused else "Pause"):
paused = not paused
bimpy.end()
ctx.render()
ctx = bimpy.Context()
ctx.init(800, 400, "Scanner 3D")
with ctx:
bimpy.themes.set_light_theme()
taille_cible = bimpy.Int(150)
largeur_cible = bimpy.Int(150)
while not ctx.should_close():
ctx.new_frame()
bimpy.set_next_window_pos(bimpy.Vec2(0, 0), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(800, 400), bimpy.Condition.Once)
bimpy.begin("Controls")
bimpy.input_text("Nom du fichier", nom, 15)
if bimpy.button("Visualisation"):
while (i < 1000000):
num = i / 1000000
bimpy.progress_bar(num)
bimpy.end()
ctx.render()
i = i + 1
if bimpy.button("Debut du Scan"):
a = 2
if bimpy.button("Visualisation du resultat"):
### Create a function to that fetches every temp and put it in a dict or anything else.
### Then run that function on a second thread
## AKA
# import threading
# def fetchTempFunction():
# return to array and use the array to fill in the values
# cool_thread = threading.Thread(target = fetchTempFunction())
# cool_thread.start()
if __name__ == "__main__":
while(not ctx.should_close()):
with ctx:
bimpy.set_next_window_pos(bimpy.Vec2(58, 15), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(720, 80), bimpy.Condition.Once)
bimpy.begin("Hardware-Rating")
bimpy.text("Welcome to Hardware-Rating,")
bimpy.same_line()
bimpy.text(f.realUser)
bimpy.text("Below are your listed computer components and any other useful information per device.")
bimpy.set_next_window_pos(bimpy.Vec2(58, 105), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(400, 315), bimpy.Condition.Once)
bimpy.begin("CPU")
bimpy.text("Your CPU is a(n):")
#try:
def render(self):
bimpy.set_next_window_pos(bimpy.Vec2(765, 30),
bimpy.Condition.FirstUseEver)
bimpy.set_next_window_size(bimpy.Vec2(410, 750),
bimpy.Condition.FirstUseEver)
if not bimpy.begin('dash window'): # open fail
bimpy.end()
return
is_lock = any([
self.train_phase_component.if_is_trainning(),
self.lines_componnet.if_is_drawing(),
self.convex_component.if_is_drawing(),
])
# dash board
if bimpy.collapsing_header('convex setting',
bimpy.TreeNodeFlags.DefaultOpen):
self.convex_component.render(is_lock)
bimpy.new_line()
if bimpy.collapsing_header('train setting',
bimpy.TreeNodeFlags.DefaultOpen):
self.lines_componnet.render(is_lock)
bimpy.new_line()
self.generator_component.render(is_lock)
bimpy.new_line()
self.optimizer_component.render(is_lock)
bimpy.new_line()
self.loss_function_component.render(is_lock)
bimpy.new_line()
self.train_component.render(is_lock)
bimpy.new_line()
if bimpy.collapsing_header('train phase',
bimpy.TreeNodeFlags.DefaultOpen):
self.train_phase_component.render(self._is_tranning_runner_running)
bimpy.new_line()
self.train_result_component.render()
bimpy.new_line()
# padding
for _ in range(5):
bimpy.new_line()
# trainning runner
if self.train_phase_component.if_is_trainning_start():
self.trainning_runner = TrainningRunner()
line_data = self.lines_componnet.get_line_data()
self.trainning_runner.create_net(width=len(line_data))
self.trainning_runner.set_net_value(line_data)
generator = self.generator_component.build_generator()
generator.set_data(
raw_points=[],
convex_points=self.convex_component.get_convex_data())
self.trainning_runner.set_generator(generator)
self.trainning_runner.set_optimizer(
self.optimizer_component.build_optimizer(
self.trainning_runner.get_net()))
self.trainning_runner.set_loss_function(
self.loss_function_component.build_loss_function())
self.trainning_runner.set_trainning_params(
self.train_component.get_train_setting())
self._is_tranning_runner_running = True
self.trainning_runner.start()
# if self.train_phase_component.if_is_trainning():
if self._is_tranning_runner_running:
# self.trainning_runner.run_once()
line_data = self.trainning_runner.get_net_value()
self.lines_componnet.set_line_data(line_data)
# if self.trainning_runner is not None:
self.train_phase_component.set_trainning_progress(
self.trainning_runner.get_trainning_progress())
self.train_result_component.set_trainning_result(
self.trainning_runner.get_tranning_result())
if self.train_phase_component.if_is_trainning_stop():
self.trainning_runner.try_to_stop()
if self._is_tranning_runner_running:
self.trainning_runner.join(1e-2)
self._is_tranning_runner_running = self.trainning_runner.is_alive()
bimpy.end()
scale = std.value * np.random.rand(2) * np.eye(2, 2)
position = np.random.rand(2) * 5
rotation = np.array([[np.cos(alpha), np.sin(alpha)],
[-np.sin(alpha), np.cos(alpha)]])
x = np.matmul(x, scale)
x = np.matmul(x, rotation)
x += position
datapoints.append((x, rotation, position, scale))
axis = x = np.array([[-1, 0], [1, 0], [0, -1], [0, 1]])
while not ctx.should_close():
ctx.new_frame()
bimpy.set_next_window_pos(bimpy.Vec2(20, 20), bimpy.Condition.Once)
bimpy.set_next_window_size(bimpy.Vec2(800, 600), bimpy.Condition.Once)
bimpy.begin("Drawings")
window_pos = bimpy.get_window_pos()
center = bimpy.Vec2(100, 100) + window_pos
m = 100.0
for i in range(len(datapoints)):
(x, R, P, S) = datapoints[i]
for j in range(x.shape[0]):
point = bimpy.Vec2(x[j, 0], x[j, 1])
bimpy.add_circle_filled(point * m + center, 5,
0xAF000000 + colors[i], 100)
def render(self, ctx, windows_info):
# calculate autoly
pos = bimpy.Vec2(
windows_info['file_brewswer_ui']['x'] +
windows_info['file_brewswer_ui']['w'] + conf.margin,
windows_info['image_shower_ui']['y'] +
windows_info['image_shower_ui']['h'] + conf.margin)
size = bimpy.Vec2(ctx.width() - pos.x - conf.margin,
conf.meta_info_height)
bimpy.set_next_window_pos(pos, bimpy.Condition.Always)
bimpy.set_next_window_size(size, bimpy.Condition.Always)
bimpy.begin(
"", bimpy.Bool(True), bimpy.WindowFlags.NoCollapse
| bimpy.WindowFlags.NoMove | bimpy.WindowFlags.NoResize
| bimpy.WindowFlags.NoTitleBar | bimpy.WindowFlags.NoScrollbar)
###########UI###########
if self.meta_info is not None:
####LINE1####
self.meta_info.setdefault('ImageWidth', '')
self.meta_info.setdefault('ImageLength', '')
bimpy.text('{}:{}x{}'.format(LANG.meta_size,
self.meta_info['ImageWidth'],
self.meta_info['ImageLength']))
bimpy.same_line(size.x / 3)
self.meta_info.setdefault('DateTimeOriginal', '')
bimpy.text('{}:{}'.format(LANG.meta_date,
self.meta_info['DateTimeOriginal']))
bimpy.same_line(size.x / 3 * 2)
self.meta_info.setdefault('Make', '')
self.meta_info.setdefault('Model', '')
bimpy.text('{}:{} {}'.format(LANG.meta_device,
self.meta_info['Make'],
self.meta_info['Model']))
####LINE2####
self.meta_info.setdefault('FocalLength', '')
bimpy.text('{}:{}'.format(LANG.meta_focal_length,
self.meta_info['FocalLength']))
bimpy.same_line(size.x / 3)
self.meta_info.setdefault('ExposureTime', '')
# truncate too high number
try:
x, y = self.meta_info['ExposureTime']
self.meta_info['ExposureTime'] = (x % 1000, y % 1000)
except:
pass
bimpy.text('{}:{}'.format(LANG.meta_exposure_time,
self.meta_info['ExposureTime']))
bimpy.same_line(size.x / 3 * 2)
self.meta_info.setdefault('ISOSpeedRatings', '')
bimpy.text('{}:{}'.format(LANG.meta_ISO_speed_ratings,
self.meta_info['ISOSpeedRatings']))
####LINE3####
bimpy.text('{}:({},{})'.format(LANG.meta_GPS, round(self.lat, 1),
round(self.lon, 1)))
bimpy.same_line(size.x / 3)
bimpy.text('{}:{}'.format(LANG.meta_location, self.location))
########################
t = {
'x': bimpy.get_window_pos().x,
'y': bimpy.get_window_pos().y,
'w': bimpy.get_window_size().x,
'h': bimpy.get_window_size().y,
'self': self,
}
bimpy.end()
return t
