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()
