def __init__(self): self._lr = bimpy.Float(0.001) self._betas_first = bimpy.Float(0.9) self._betas_second = bimpy.Float(0.999) self._eps = bimpy.Float(1e-8) self._weight_decay = bimpy.Float(0) self._amsgrad = bimpy.Bool(False)
def __init__(self): self._lr = bimpy.Float(0.1) self._momentum = bimpy.Float(0) self._dampening = bimpy.Float(0) self._weight_decay = bimpy.Float(0) self._nesterov = bimpy.Bool(False) self._hint_nesterov = False
def set_convex_draw_value(self, value: Dict[str, Union[List[Point], str]]): r""" value: { 'convex': <convex point list, List[Point]>, 'state': <str, 'none', 'doing', 'done', 'cancel'>, } """ if value['state'] == 'none': return if value['state'] == 'doing': self._convex_number.value = len(value['convex']) self._convex_data = [[bimpy.Float(item.x), bimpy.Float(item.y)] for item in value['convex']] return if value['state'] == 'cancel': self._convex_number.value = len(self._convex_data_backup) self._convex_data = [[bimpy.Float(item[0]), bimpy.Float(item[1])] for item in self._convex_data_backup] self._convex_draw_flag = False if value['state'] == 'done': if len(value['convex']) < 3: self._convex_number.value = len(self._convex_data_backup) self._convex_data = [[bimpy.Float(item[0]), bimpy.Float(item[1])] for item in self._convex_data_backup] else: self._convex_number.value = len(value['convex']) self._convex_data = [[bimpy.Float(item.x), bimpy.Float(item.y)] for item in value['convex']] self._convex_draw_flag = False
def render(self, is_lock): bimpy.set_next_tree_node_open(True, bimpy.Condition.FirstUseEver) if not bimpy.tree_node('convex points##convex_component'): return bimpy.same_line() bimpy_tools.help_marker('Convex points should be presented in counter-clockwise order') flags = bimpy.InputTextFlags.EnterReturnsTrue if is_lock: flags |= bimpy.InputTextFlags.ReadOnly last_convex_number_value = self._convex_number.value if bimpy.input_int('number##convex_component', self._convex_number, 1, 1, flags): self._convex_number.value = max(3, self._convex_number.value) if last_convex_number_value > self._convex_number.value: self._convex_data = self._convex_data[:self._convex_number.value] # cut back points else: self._convex_data.extend([ [bimpy.Float(0), bimpy.Float(0)] for _ in range(last_convex_number_value, self._convex_number.value) ]) # show convex value setting bimpy.set_next_tree_node_open(self._convex_number.value < 10, bimpy.Condition.FirstUseEver) if bimpy.tree_node('convex value ({})##convex_component'.format(self._convex_number.value)): for index in range(self._convex_number.value): bimpy.push_item_width(210) bimpy.input_float2( '{:<3d}'.format(index), self._convex_data[index][0], self._convex_data[index][1], flags=flags ) bimpy.pop_item_width() bimpy.tree_pop() # draw part bimpy.new_line() if bimpy.button('draw convex##convex_component') and not is_lock: self._convex_data_backup = [[item[0].value, item[1].value] for item in self._convex_data] self._convex_draw_flag = True self._convex_data = [] self._convex_number.value = 0 bimpy.tree_pop()
def __init__(self): self._a = bimpy.Float(math.sqrt(5)) self._mode_list = ['fan_in', 'fan_out'] self._select_mode = self._mode_list[0] self._nonlinearity_list = ['leaky_relu', 'relu'] self._select_nonlinearity = self._nonlinearity_list[0]
def __init__(self, width, height, title): self.width = width self.height = height self.identify = False self.ctx = bimpy.Context() self.ctx.init(width, height, title) self.min_aspect_ratio = bimpy.Float(0.0)
def __init__(self): self._convex_number = bimpy.Int(4) self._convex_data = [ [bimpy.Float(0.15), bimpy.Float(0.15)], [bimpy.Float(0.85), bimpy.Float(0.15)], [bimpy.Float(0.85), bimpy.Float(0.85)], [bimpy.Float(0.15), bimpy.Float(0.85)], ] self._convex_data_backup = None self._convex_draw_flag = False
def ranged_slider(name, value, range_info): f = bimpy.Float(value) ret = None rng = (range_info.max - range_info.min) spd = .0025 * rng if rng > 0 else .1 if bimpy.drag_float("##v_" + name, f, spd, range_info.min, range_info.max): ret = ps.ConfigurationInfo.ClampFloat(range_info, f.value) bimpy.same_line() if bimpy.button("init##b_" + name): ret = range_info.initial return ret
def object_inspector(self): has_selection = self.selected_node is not None bimpy.text("ID: %s" % (str(self.selected_node.id) if has_selection else '')) nstr = bimpy.String(self.selected_node.name if has_selection else '') bimpy.input_text('Name', nstr, 256) nwidth = bimpy.Float(self.selected_node.width if has_selection else 0.) nheigth = bimpy.Float( self.selected_node.height if has_selection else 0.) bimpy.input_float2('size', nwidth, nheigth) nposx = bimpy.Float(self.selected_node.pos_x if has_selection else 0.) nposy = bimpy.Float(self.selected_node.pos_y if has_selection else 0.) bimpy.input_float2('position', nposx, nposy) ncolor = bimpy.Vec4( *[x / 255. for x in self.selected_node.color] if has_selection else (0, 0, 0, 0)) bimpy.color_edit("Color", ncolor) nradius = [ self.selected_node.radius.x, self.selected_node.radius.y, self.selected_node.radius.z, self.selected_node.radius.w ] if has_selection else [0., 0., 0., 0.] nradius = [bimpy.Float(x) for x in nradius] bimpy.input_float4("radius", *nradius) if has_selection: self.selected_node.name = nstr.value self.selected_node.width = nwidth.value self.selected_node.height = nheigth.value self.selected_node.pos_x = nposx.value self.selected_node.pos_y = nposy.value self.selected_node.color = (int(255 * ncolor.x), int( 255 * ncolor.y), int(255 * ncolor.z), int(255 * ncolor.w)) self.selected_node.radius = getoolkit.vec4( *[x.value for x in nradius])
def __init__(self, port, cam_id): self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.server_socket.bind(('', port)) self.server_socket.settimeout(5.0) self.frame = None self.orientation = 0 self.MAX_INT = (2**31) - 1 self.packet_size = 1000 self.port = port self.cam_id = cam_id self.first = True self.running = True self.cmd_string = '' self.last_timestamp = 0 self.process = False #self.V = 0 #self.H = 0 self.stream_width = bimpy.Float(320) self.stream_height = bimpy.Float(240) atexit.register(self.release) threading.Thread(target=self.reciever_thread).start()
def update_pic(self, f_name): # init self.scale = bimpy.Float(100.0) self.last_scale = 100.0 # resize and update pic by message im = Image.open(f_name) self.raw_im = im im = self.i_s.resize(im, self.size.x, self.size.y - 45 - 40) self.now_im = im self.set_im(im) # reset self.labels = None if self.auto.value == True: self.object_detection()
import bimpy import time import random from win32api import GetKeyState import win32api from pynput.mouse import Button, Controller ctx = bimpy.Context() MinCPS = bimpy.Float(8.5) MaxCPS = bimpy.Float(10.9) OnlyOneHeader = bimpy.Bool(True) Toggle = 0 mouseclick = Controller() MinDelay = 1000 MaxDelay = 1000 BaseDelay = 1000 BarColor = bimpy.Vec4(0.16078431, 0.2901960, 0.47843137, 0.95) HeaderColor = bimpy.Vec4(0.25882352, 0.58823529, 0.9803921568, 0.95) HeaderHoverColor = bimpy.Vec4(0.43529411, 0.694117647, 0.9803921568, 0.95) TextColor = bimpy.Vec4(1, 1, 1, 1) SliderColor = bimpy.Vec4(0.06078431, 0.1901960, 0.47843137, 0.95) SliderActiveColor = bimpy.Vec4(0.16078431, 0.2901960, 0.47843137, 0.95) CheckMarkColor = bimpy.Vec4(0.43529411, 0.694117647, 0.9803921568, 0.95) ctx.init(520, 320, "") print("Loading...") while (not ctx.should_close()): ctx.new_frame() if True:
def sample(cfg, logger): torch.cuda.set_device(0) model = Model(startf=cfg.MODEL.START_CHANNEL_COUNT, layer_count=cfg.MODEL.LAYER_COUNT, maxf=cfg.MODEL.MAX_CHANNEL_COUNT, latent_size=cfg.MODEL.LATENT_SPACE_SIZE, truncation_psi=cfg.MODEL.TRUNCATIOM_PSI, truncation_cutoff=cfg.MODEL.TRUNCATIOM_CUTOFF, mapping_layers=cfg.MODEL.MAPPING_LAYERS, channels=cfg.MODEL.CHANNELS, generator=cfg.MODEL.GENERATOR, encoder=cfg.MODEL.ENCODER) model.cuda(0) model.eval() model.requires_grad_(False) decoder = model.decoder encoder = model.encoder mapping_tl = model.mapping_d mapping_fl = model.mapping_f dlatent_avg = model.dlatent_avg logger.info("Trainable parameters generator:") count_parameters(decoder) logger.info("Trainable parameters discriminator:") count_parameters(encoder) arguments = dict() arguments["iteration"] = 0 model_dict = { 'discriminator_s': encoder, 'generator_s': decoder, 'mapping_tl_s': mapping_tl, 'mapping_fl_s': mapping_fl, 'dlatent_avg': dlatent_avg } checkpointer = Checkpointer(cfg, model_dict, {}, logger=logger, save=False) extra_checkpoint_data = checkpointer.load() model.eval() layer_count = cfg.MODEL.LAYER_COUNT def encode(x): Z, _ = model.encode(x, layer_count - 1, 1) Z = Z.repeat(1, model.mapping_f.num_layers, 1) return Z def decode(x): layer_idx = torch.arange(2 * layer_count)[np.newaxis, :, np.newaxis] ones = torch.ones(layer_idx.shape, dtype=torch.float32) coefs = torch.where(layer_idx < model.truncation_cutoff, ones, ones) # x = torch.lerp(model.dlatent_avg.buff.data, x, coefs) return model.decoder(x, layer_count - 1, 1, noise=True) path = 'dataset_samples/faces/realign1024x1024' paths = list(os.listdir(path)) paths.sort() paths_backup = paths[:] randomize = bimpy.Bool(True) current_file = bimpy.String("") ctx = bimpy.Context() attribute_values = [bimpy.Float(0) for i in indices] W = [ torch.tensor(np.load("principal_directions/direction_%d.npy" % i), dtype=torch.float32) for i in indices ] rnd = np.random.RandomState(5) def loadNext(): img = np.asarray(Image.open(path + '/' + paths[0])) current_file.value = paths[0] paths.pop(0) if len(paths) == 0: paths.extend(paths_backup) if img.shape[2] == 4: img = img[:, :, :3] im = img.transpose((2, 0, 1)) x = torch.tensor(np.asarray(im, dtype=np.float32), device='cpu', requires_grad=True).cuda() / 127.5 - 1. if x.shape[0] == 4: x = x[:3] needed_resolution = model.decoder.layer_to_resolution[-1] while x.shape[2] > needed_resolution: x = F.avg_pool2d(x, 2, 2) if x.shape[2] != needed_resolution: x = F.adaptive_avg_pool2d(x, (needed_resolution, needed_resolution)) img_src = ((x * 0.5 + 0.5) * 255).type(torch.long).clamp( 0, 255).cpu().type(torch.uint8).transpose(0, 2).transpose(0, 1).numpy() latents_original = encode(x[None, ...].cuda()) latents = latents_original[0, 0].clone() latents -= model.dlatent_avg.buff.data[0] for v, w in zip(attribute_values, W): v.value = (latents * w).sum() for v, w in zip(attribute_values, W): latents = latents - v.value * w return latents, latents_original, img_src def loadRandom(): latents = rnd.randn(1, cfg.MODEL.LATENT_SPACE_SIZE) lat = torch.tensor(latents).float().cuda() dlat = mapping_fl(lat) layer_idx = torch.arange(2 * layer_count)[np.newaxis, :, np.newaxis] ones = torch.ones(layer_idx.shape, dtype=torch.float32) coefs = torch.where(layer_idx < model.truncation_cutoff, ones, ones) dlat = torch.lerp(model.dlatent_avg.buff.data, dlat, coefs) x = decode(dlat)[0] img_src = ((x * 0.5 + 0.5) * 255).type(torch.long).clamp( 0, 255).cpu().type(torch.uint8).transpose(0, 2).transpose(0, 1).numpy() latents_original = dlat latents = latents_original[0, 0].clone() latents -= model.dlatent_avg.buff.data[0] for v, w in zip(attribute_values, W): v.value = (latents * w).sum() for v, w in zip(attribute_values, W): latents = latents - v.value * w return latents, latents_original, img_src latents, latents_original, img_src = loadNext() ctx.init(1800, 1600, "Styles") def update_image(w, latents_original): with torch.no_grad(): w = w + model.dlatent_avg.buff.data[0] w = w[None, None, ...].repeat(1, model.mapping_f.num_layers, 1) layer_idx = torch.arange(model.mapping_f.num_layers)[np.newaxis, :, np.newaxis] cur_layers = (7 + 1) * 2 mixing_cutoff = cur_layers styles = torch.where(layer_idx < mixing_cutoff, w, latents_original) x_rec = decode(styles) resultsample = ((x_rec * 0.5 + 0.5) * 255).type(torch.long).clamp( 0, 255) resultsample = resultsample.cpu()[0, :, :, :] return resultsample.type(torch.uint8).transpose(0, 2).transpose(0, 1) im_size = 2**(cfg.MODEL.LAYER_COUNT + 1) im = update_image(latents, latents_original) print(im.shape) im = bimpy.Image(im) display_original = True seed = 0 while not ctx.should_close(): with ctx: new_latents = latents + sum( [v.value * w for v, w in zip(attribute_values, W)]) if display_original: im = bimpy.Image(img_src) else: im = bimpy.Image(update_image(new_latents, latents_original)) bimpy.begin("Principal directions") bimpy.columns(2) bimpy.set_column_width(0, im_size + 20) bimpy.image(im) bimpy.next_column() for v, label in zip(attribute_values, labels): bimpy.slider_float(label, v, -40.0, 40.0) bimpy.checkbox("Randomize noise", randomize) if randomize.value: seed += 1 torch.manual_seed(seed) if bimpy.button('Next'): latents, latents_original, img_src = loadNext() display_original = True if bimpy.button('Display Reconstruction'): display_original = False if bimpy.button('Generate random'): latents, latents_original, img_src = loadRandom() display_original = False if bimpy.input_text( "Current file", current_file, 64) and os.path.exists(path + '/' + current_file.value): paths.insert(0, current_file.value) latents, latents_original, img_src = loadNext() bimpy.end()
TakeWebCamIamge() image, width, height = getCamImage() dirvecx = 0 dirvecy = 0 dirvecxnorm = 0 dirvecynorm = 0 dirvecmag = 0 dirvecmagnorm = 0 #if (dirvecx<0): ################################################## #UI im = bimpy.Image(image) f1 = bimpy.Float() f2 = bimpy.Float() f3 = bimpy.Float() facestr = "" while (not ctx.should_close()): with ctx: TakeWebCamIamge() image, width, height = getCamImage() faces = DetectFace(image) if (len(faces) > 0): facestr, headx, heady = DrawFaces(image, faces) dirvecx, dirvecy, dirvecxnorm, dirvecynorm, dirvecmag, dirvecmagnorm = DrawHUD( image, width, height, headx, heady)
import bimpy import pkg_resources print(pkg_resources.get_distribution("bimpy").version) ctx = bimpy.Context() ctx.init(600, 600, "Sliders") with ctx: bimpy.themes.set_light_theme() #slider float3 f1 = bimpy.Float() f2 = bimpy.Float() f3 = bimpy.Float() #vertical slider f4 = bimpy.Float() f5 = bimpy.Float() #slider_angle f6 = bimpy.Float() #slider int2 i1 = bimpy.Int() i2 = bimpy.Int() while (not ctx.should_close()): ctx.new_frame() bimpy.begin("Sliders!", flags=bimpy.WindowFlags.AlwaysAutoResize)
from pyfirmata import Arduino, util, pyfirmata from array import array import threading import time import bimpy finalCom = 1 # Minimum port is 1 maxInterval = bimpy.Float() pinNumber = bimpy.Int() minPWM = bimpy.Int(0) maxPWM = bimpy.Int(1) # trueBool = bimpy.Bool(True) toggleLight = False plot_values = array('f',[]) textToggleButton = 'Start flashing LED' buttonNewColorEnabled = bimpy.Vec4(0,0.33,0.0078,1); # bimpy.push_style_color(bimpy.Colors.Button,buttonColoredEnabled) def checkPWM(): if (currentBoard.digital[pinNumber.value].mode == pyfirmata.PWM): return 1 try: currentBoard.digital[pinNumber.value].mode = pyfirmata.PWM return 1 except: return 0 def flashLED(): for i in range(0,9999999): if (toggleLight == True):
class image_shower_ui: i_s = image_shower() raw_im = None im = None labels = None now_im = None scale = bimpy.Float(100.0) last_scale = 100.0 auto = bimpy.Bool(False) select_label = '' 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 update_pic(self, f_name): # init self.scale = bimpy.Float(100.0) self.last_scale = 100.0 # resize and update pic by message im = Image.open(f_name) self.raw_im = im im = self.i_s.resize(im, self.size.x, self.size.y - 45 - 40) self.now_im = im self.set_im(im) # reset self.labels = None if self.auto.value == True: self.object_detection() def object_detection(self): img = np.asarray(self.now_im) self.bbox, self.labels, self.confidence = cv.detect_common_objects(img) self.COLORS = np.random.uniform(0, 255, size=(80, 3)) self.classes = populate_class_labels() for i, label in enumerate(self.labels): color = self.COLORS[self.classes.index(label)] if True: label += ' ' + str(format(self.confidence[i] * 100, '.2f')) + '%' cv2.rectangle(img, (self.bbox[i][0], self.bbox[i][1]), (self.bbox[i][2], self.bbox[i][3]), color, 2) # cv2.putText(img, label, # (self.bbox[i][0], self.bbox[i][1] - 10), # cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2) self.set_im(img) def set_im(self, im): self.im = bimpy.Image(im)
import sys import os if os.path.exists("../cmake-build-debug/"): print('Running Debugging session!') sys.path.insert(0, "../cmake-build-debug/") import bimpy as bp ctx = bp.Context() ctx.init(600, 600, "Hello") str = bp.String() f = bp.Float() while not ctx.should_close(): with ctx: bp.begin_root("") bp.text("Hello, world!") if bp.button("OK"): print(str.value) bp.input_text('string', str, 256) bp.slider_float("float", f, 0.0, 1.0) bp.end()
res = ((current_time) - (g_last_timestamp)) g_last_timestamp = current_time return res def fail(msg): print(((bcolors.FAIL) + ("{:8d} FAIL ".format(milli_since_last())) + (msg) + (bcolors.ENDC))) sys.stdout.flush() def plog(msg): print(((bcolors.OKGREEN) + ("{:8d} LOG ".format(milli_since_last())) + (msg) + (bcolors.ENDC))) sys.stdout.flush() args = docopt.docopt(__doc__, version="0.0.1") if (args["--verbose"]): print(args) ctx = b.Context() ctx.init(600, 600, "Hello") str = b.String() f = b.Float() while (not (ctx.should_close())): with ctx: b.text("hello world") if (b.button("OK")): print(str.value) b.input_text("string", str, 256) b.slider_float("float", f, (0.0e+0), (1.e+0))
import bimpy ctx = bimpy.Context() ctx.init(600, 600, "Hello") str = bimpy.String() f = bimpy.Float(); while(not ctx.should_close()): with ctx: bimpy.text("Hello, world!") if bimpy.button("OK"): print(str.value) bimpy.input_text('string', str, 256) bimpy.slider_float("float", f, 0.0, 1.0)
import bimpy import pkg_resources print(pkg_resources.get_distribution("bimpy").version) ctx = bimpy.Context() ctx.init(600, 600, "Sliders") with ctx: bimpy.themes.set_light_theme() #slider float3 f1 = bimpy.Float(); f2 = bimpy.Float(); f3 = bimpy.Float(); #vertical slider f4 = bimpy.Float(); f5 = bimpy.Float(); #slider_angle f6 = bimpy.Float(); #slider int2 i1 = bimpy.Int(); i2 = bimpy.Int(); while(not ctx.should_close()): ctx.new_frame() bimpy.begin("Sliders!", flags=bimpy.WindowFlags.AlwaysAutoResize)
import pyglet, math, ctypes, numpy, bimpy from pyglet.gl import * from OpenGL.GLUT import * ctx = bimpy.Context() ctx.init(330, 110, 'Graph Settings') equation = bimpy.String('math.cos(x)') x_min = bimpy.Float(-5) x_max = bimpy.Float(5) def glut_string(x, y, text, color=[1, 1, 1]): """Draw a string using GLUT functions.""" glutInit() glColor3f(color[0], color[1], color[2]) glRasterPos2f(x, y) for ch in text: glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ctypes.c_int(ord(ch))) def circle(x, y, radius): iterations = int(2 * radius * math.pi) s = math.sin(2 * math.pi / iterations) c = math.cos(2 * math.pi / iterations) dx, dy = radius, 0 glBegin(GL_TRIANGLE_FAN) glVertex2f(x, y) for i in range(iterations + 1):
def render(self, is_lock): bimpy.set_next_tree_node_open(True, bimpy.Condition.FirstUseEver) if not bimpy.tree_node('lines##lines_component'): return # number setting flags = bimpy.InputTextFlags.EnterReturnsTrue if is_lock: flags |= bimpy.InputTextFlags.ReadOnly if bimpy.input_int('number##lines_component', self._line_number, 1, 1, flags): self._line_number.value = max(3, self._line_number.value) if self._last_line_number_value > self._line_number.value: self._line_data = self._line_data[:self._line_number.value] # cut back points else: self._line_data.extend([ [bimpy.Float(0), bimpy.Float(0), bimpy.Float(0)] for _ in range(self._last_line_number_value, self._line_number.value) ]) self._last_line_number_value = self._line_number.value # print('line number change to {}'.format(self._line_number.value)) # show line value setting bimpy.set_next_tree_node_open(self._line_number.value < 10, bimpy.Condition.FirstUseEver) self._highlight_line_index = None if bimpy.tree_node('line value ({})'.format(self._line_number.value)): for index in range(self._line_number.value): bimpy.push_item_width(210) bimpy.input_float3( '{:<3d}'.format(index), self._line_data[index][0], self._line_data[index][1], self._line_data[index][2], flags=flags ) bimpy.pop_item_width() if bimpy.is_item_hovered(): self._highlight_line_index = index bimpy.same_line() if bimpy.button('rev##lines_component{}'.format(index)) and not is_lock: for j in range(3): self._line_data[index][j].value = -self._line_data[index][j].value if bimpy.is_item_hovered(): self._highlight_line_index = index bimpy.same_line() if bimpy.button('draw##lines_component{}'.format(index)) and not is_lock: self._waitting_draw_line_index = index bimpy.set_window_focus('canvas window##canvas') if bimpy.is_item_hovered(): self._highlight_line_index = index bimpy.tree_pop() # random setting bimpy.new_line() if bimpy.button('random##lines_component') and not is_lock: initializer = self.initializer_component.build_initializer() random_lines = initializer.random(self._line_number.value) for index in range(self._line_number.value): self._line_data[index][0].value = random_lines[index].a self._line_data[index][1].value = random_lines[index].b self._line_data[index][2].value = random_lines[index].c self.initializer_component.render(is_lock) bimpy.tree_pop()
def __init__(self): self._line_number = bimpy.Int(4) self._last_line_number_value = self._line_number.value self._line_data = [ [bimpy.Float(1), bimpy.Float(1), bimpy.Float(-1)], [bimpy.Float(1), bimpy.Float(-1), bimpy.Float(-0.5)], [bimpy.Float(-1), bimpy.Float(1), bimpy.Float(-0.5)], [bimpy.Float(0), bimpy.Float(-1), bimpy.Float(0.5)], ] self.initializer_component = InitializerComponent() self._highlight_line_index = None self._waitting_draw_line_index = None
import bimpy from PIL import Image import concurrent.futures import threading import queue import random import time from shoes import shoes temp_separation_test = bimpy.Float(0.5) def log(text): print("log :: %s" % (text)) class MessagePipeline(object): def __init__(self): # thread safe queue self.queue = queue.Queue(maxsize = 1000) # Event object to notify queue has changed self.event = threading.Event() class Message: def __init__(self): self.idd = None self.text = None self.point = None class Data:
def view_legacy_controller(pl): bimpy.begin("Single File") bimpy.text("No file" if not ViewConfig.fileName else ViewConfig.fileName) if bimpy.button("Open File"): fn = askopenfilename(filetypes=(("WAV files", "*.wav"), ("AIFF files", "*.aif"))) if fn: _lc.OpenFile(fn) ViewConfig.fileName = fn bimpy.text("No configuration file" if not ViewConfig.configFileName else ViewConfig.configFileName) if bimpy.button("Open Configuration"): fn = askopenfilename(filetypes=(("JSON files", "*.ps.json"), ("All files", "*.*"))) if bimpy.button("Save Configuration"): pass bimpy.separator() vcfg = bimpy.Bool(ViewConfig.showParameters) if bimpy.checkbox("Edit Configuration", vcfg): ViewConfig.showParameters = vcfg.value bimpy.separator() if (not _lc.IsPlaying()): if bimpy.button("Play"): _lc.Play() bimpy.same_line() if (_lc.IsPlaying()): if bimpy.button("Stop"): _lc.Stop() bimpy.same_line() f = bimpy.Float(_lc.GetSeek()) if bimpy.slider_float("##seek", f, 0, 1): if (not _lc.IsPlaying()): _lc.Seek(f.value) #bimpy.text(str(_lc.GetSeek())); bimpy.separator() bimpy.slider_float("Start##region_start", bimpy.Float(0), 0, 1) bimpy.slider_float("End##region_end", bimpy.Float(1), 0, 1) if bimpy.button("Render file (default)"): path = os.path.abspath(__file__) output_file = os.path.dirname(path) + "/render.wav" _lc.RenderToFile(output_file) # bimpy.text("render: "+str(_lc.GetRenderPercent())) # if bimpy.button("Cancel"): # _lc.CancelRender() # if bimpy.button("Render async (default)"): # path = os.path.abspath(__file__) # output_file = os.path.dirname(path)+"/render_async.wav" # _lc.RenderToFileAsync(output_file) # bimpy.text(str(_lc.GetRenderPercent())) # bimpy.button("Cancel Render") # # if bimpy.button("Render Task"): # if not ViewConfig.renderTask: # path = os.path.abspath(__file__) # input_file = os.path.dirname(path)+"/test_file.wav" # output_file = os.path.dirname(path)+"/render-task.wav" # # ViewConfig.renderTask = ps.LegacyRenderTask(input_file, output_file, _lc.RenderRange(), _lc.Parameters()); # ViewConfig.renderTask.StartRender() # if ViewConfig.renderTask: # bimpy.text(str(ViewConfig.renderTask.GetRenderPercent())) # bimpy.button("Cancel Render") # bimpy.end() # if ViewConfig.showParameters: #cfg = _lc.Parameters() if edit_config(_parameters) == True: _lc.SetParameters(_parameters) print("edit") pass
import bimpy import numpy as np ctx = bimpy.Context() ctx.init(1200, 1200, "Draw Commands Test") with ctx: bimpy.themes.set_light_theme() DATA_POINTS = bimpy.Int(30) CLASTERS = bimpy.Int(4) std = bimpy.Float(0.5) colors = [ 0x4b19e6, 0x4bb43c, 0x19e1ff, 0xc88200, 0x3182f5, 0xb41e91, 0xf0f046, 0xf032e6, 0xd2f53c, 0xfabebe, 0x008080, 0xe6beff, 0xaa6e28, 0xfffac8, 0x800000, 0xaaffc3, 0x808000, 0xffd8b1, 0x000080, 0x808080, 0xFFFFFF, 0x000000 ] datapoints = [] def generate_fake_data(): datapoints.clear() for i in range(CLASTERS.value): x = np.random.normal(size=(DATA_POINTS.value, 2)) alpha = np.random.rand() scale = std.value * np.random.rand(2) * np.eye(2, 2)
import bimpy as bp context = bp.Context() context.init(600, 600, "Hello, Bimpy!") label_content = bp.String() spinner_content = bp.Float() while not context.should_close(): with context: bp.text("Hello, Bimpy!") if bp.button("Ok"): print("Hello!") bp.input_text("string", label_content, 256) bp.slider_float("float", spinner_content, 0.0, 1.0)
c = b.Context() c.init(1200, 1200, "bimpy test") img = Image.new( "RGBA", (512, 512), ) px = img.load() for x in range(512): for y in range(512): r = int(255.0 * float(x) / 512.0) g = int(255.0 * float(y) / 512.0) px[x, y] = (r, g, max(255 - r - g, 0), 255) b_img = b.Image(img) b_f1 = b.Float() b_f2 = b.Float() b_f3 = b.Float() while not c.should_close(): with c: b.text("hi") if b.button("cat"): print("mew") b.input_float("float1", b_f1, 0.0, 1.0) b.image(b_img) b.slider_float3("float", b_f1, b_f2, b_f3, 0.0, 1.0)
def __init__(self): super(App, self).__init__(title='Test') self.string = bp.String() self.f = bp.Float()