def test_display_camera(self): from displayarray import display import numpy as np def black_and_white(arr): return (np.sum(arr, axis=-1) / 3).astype(np.uint8) display(0, callbacks=black_and_white, blocking=True)
def test_nested_frames(self): def nest_frame(frame): frame = np.asarray([[[[[[frame]]]]], [[[[[frame]]], [[[frame]]]]]]) return frame display(0, callbacks=nest_frame, window_names=["1", "2", "3"], blocking=True)
def test_display_numpy_callback(self): from displayarray import display import numpy as np arr = np.random.normal(0.5, 0.1, (500, 500, 3)) def fix_arr_cv(arr_in): arr_in[:] += np.random.normal(0.01, 0.005, (500, 500, 3)) arr_in %= 1.0 display(arr, callbacks=fix_arr_cv, blocking=True)
def test_backpropogate_diffs_cpu(): d = display(test_image_smol_smol, size=(1, 1)) edge_kernel = np.random.randint(0, 127, midget_rgc(2).shape).astype(dtype=np.float32) / 127.0 kernel_stride_x = kernel_stride_y = 1 kernel_padding_x = kernel_padding_y = 1 kernel_dilation_x = kernel_dilation_y = 0 while d: if d.frames: frame = next(iter(d.frames.values()))[0].astype(np.float32) frame = frame[np.newaxis, ...] frame = np.swapaxes(frame, 1, 3) d_inp_image = np.zeros_like(frame) out_error = np.random.randint(0, 127, frame.shape).astype(dtype=np.float32) / 127.0 d_kernel = np.zeros_like(edge_kernel) dense_conv_backward_2d_fast(frame, d_inp_image, edge_kernel, d_kernel, out_error, (kernel_stride_x, kernel_stride_y), (kernel_padding_x, kernel_padding_y), ) out_error = np.swapaxes(out_error, 1, 3) out_error = out_error[0, ...] d.update(out_error, 'out err') d_inp_image = np.swapaxes(d_inp_image, 1, 3) d_inp_image = d_inp_image[0, ...] d.update(d_inp_image / d_inp_image.max(), 'in err') print(d_kernel)
def test_denoise_cpu(): d = display(0, size=(1, 1)) edge_kernel = np.random.randint(0, 127, midget_rgc(2).shape).astype(dtype=np.float32) / 127.0 kernel_stride_x = kernel_stride_y = 1 kernel_padding_x = kernel_padding_y = 1 kernel_dilation_x = kernel_dilation_y = 0 while d: if d.frames: frame = next(iter(d.frames.values()))[0].astype(np.float32) / 256.0 frame = cv2.resize(frame, dsize=(8,8), interpolation=cv2.INTER_NEAREST ) frame = frame[np.newaxis, ...] frame = np.swapaxes(frame, 1, 3) output = np.zeros_like(frame) noise = np.random.randint(0, 127, frame.shape).astype(dtype=np.float32) / 256.0 noised_frame = frame + noise dense_conv_forward_2d_fast(noised_frame, edge_kernel, output, (kernel_stride_x, kernel_stride_y), (kernel_padding_x, kernel_padding_y)) out_error = output - frame d_inp_image = np.zeros_like(frame) d_kernel = np.zeros_like(edge_kernel) dense_conv_backward_2d_fast(frame, d_inp_image, edge_kernel, d_kernel, out_error, (kernel_stride_x, kernel_stride_y), (kernel_padding_x, kernel_padding_y), ) frame = np.swapaxes(frame, 1, 3) frame = frame[0, ...] output = np.swapaxes(output, 1, 3) output = output[0, ...] out_error = np.swapaxes(out_error, 1, 3) out_error = out_error[0, ...] d_inp_image = np.swapaxes(d_inp_image, 1, 3) d_inp_image = d_inp_image[0, ...] noised_frame = np.swapaxes(noised_frame, 1, 3) noised_frame = noised_frame[0, ...] d.update(frame, 'mini frame') d.update(noised_frame, 'noised frame') d.update(output, 'out img') d.update(out_error, 'out err') d.update(d_inp_image / d_inp_image.max(), 'in err') print(d_kernel) d_half = (np.average(np.abs(d_kernel.copy())))/1e6 edge_kernel -= d_kernel * d_half
def main(argv=None): """Process command line arguments.""" arguments = docopt(__doc__, argv=argv) if arguments["--version"]: from displayarray import __version__ print(f"DisplayArray V{__version__}") return from displayarray import display vids = [int(w) for w in arguments["--webcam"]] + arguments["--video"] v_disps = None if vids: v_disps = display(*vids, blocking=False) from displayarray.frame.frame_updater import read_updates_ros, read_updates_zero_mq topics = arguments["--topic"] topics_split = [t.split(",") for t in topics] d = display() async def msg_recv(): nonlocal d while d: if arguments["--message-backend"] == "ROS": async for v_name, frame in read_updates_ros( [t for t, d in topics_split], [d for t, d in topics_split]): d.update(arr=frame, id=v_name) if arguments["--message-backend"] == "ZeroMQ": async for v_name, frame in read_updates_zero_mq( *[bytes(t, encoding="ascii") for t in topics]): d.update(arr=frame, id=v_name) async def update_vids(): while v_disps: if v_disps: v_disps.update() await asyncio.sleep(0) async def runner(): await asyncio.wait([msg_recv(), update_vids()]) loop = asyncio.get_event_loop() loop.run_until_complete(runner()) loop.close()
def test_display_numpy_loop(self): from displayarray import display import numpy as np arr = np.random.normal(0.5, 0.1, (100, 100, 3)) with display(arr) as displayer: while displayer: arr[:] += np.random.normal(0.001, 0.0005, (100, 100, 3)) arr %= 1.0
def test_display_video(self): from displayarray import display import math as m def forest_color(arr): forest_color.i += 1 arr[..., 0] = (m.sin(forest_color.i * (2 * m.pi) * .4 / 360) * 255 + arr[..., 0]) % 255 arr[..., 1] = (m.sin( (forest_color.i * (2 * m.pi) * .5 + 45) / 360) * 255 + arr[..., 1]) % 255 arr[..., 2] = (m.cos(forest_color.i * (2 * m.pi) * .3 / 360) * 255 + arr[..., 2]) % 255 forest_color.i = 0 display("fractal test.mp4", callbacks=forest_color, blocking=True, fps_limit=120)
def _init_cam(self, cam): """Initialize the input camera.""" self._pre_crop_callback = crop.Crop( output_size=self.crop_settings.PRE_LENS).enable_mouse_control() self._lens_callback = lens.BarrelPyTorch() self._post_crop_callback = crop.Crop( output_size=self.crop_settings.POST_LENS).enable_mouse_control() if not isinstance(cam, Iterable): cam = [cam] self.cam = (display( *cam, size=self.crop_settings.CAM_SIZE_REQUEST).add_callback( self._pre_crop_callback).add_callback( self._lens_callback).add_callback( self._post_crop_callback).wait_for_init())
def test_display_tensorflow(self): from displayarray import display import numpy as np from tensorflow.keras import layers, models import tensorflow as tf for gpu in tf.config.experimental.list_physical_devices("GPU"): tf.compat.v2.config.experimental.set_memory_growth(gpu, True) displayer = display("fractal test.mp4") displayer.wait_for_init() autoencoder = models.Sequential() autoencoder.add( layers.Conv2D(20, (3, 3), activation="sigmoid", input_shape=displayer.frames[0].shape)) autoencoder.add( layers.Conv2D(20, (3, 3), activation="sigmoid", input_shape=displayer.frames[0].shape)) autoencoder.add(layers.Conv2DTranspose(3, (3, 3), activation="sigmoid")) autoencoder.add(layers.Conv2DTranspose(3, (3, 3), activation="sigmoid")) autoencoder.compile(loss="mse", optimizer="adam") while displayer: grab = tf.convert_to_tensor( displayer.FRAME_DICT["fractal test.mp4frame"][np.newaxis, ...].astype( np.float32) / 255.0) grab_noise = tf.convert_to_tensor( (((displayer.FRAME_DICT["fractal test.mp4frame"][ np.newaxis, ...].astype(np.float32) + np.random.uniform(0, 255, grab.shape)) / 2) % 255) / 255.0) displayer.update((grab_noise.numpy()[0] * 255.0).astype(np.uint8), "uid for grab noise") autoencoder.fit(grab_noise, grab, steps_per_epoch=1, epochs=1) output_image = autoencoder.predict(grab, steps=1) displayer.update((output_image[0] * 255.0).astype(np.uint8), "uid for autoencoder output")
def test_forward_rgc_cpu(): d = display(test_image_smol, size=(1, 1)) edge_kernel = midget_rgc(2) kernel_stride_x = kernel_stride_y = 1 kernel_padding_x = kernel_padding_y = 1 kernel_dilation_x = kernel_dilation_y = 0 while d: if d.frames: frame = next(iter(d.frames.values())) in_frame = frame[0].astype(dtype=np.float32) edge_out = dense_conv_forward_2d(in_frame, edge_kernel, (kernel_stride_x, kernel_stride_y), (kernel_padding_x, kernel_padding_y)) d.update(edge_out / 256.0, 'blur')
def profile_reading(total_seconds=5): t_init = t01 = time.time() times = [] started = False for up in display(0, size=(1, 1)): if up: t1 = time.time() if started: times.append((t1 - t01) * 1000) t01 = t1 started = True if started: t2 = time.time() if t2 - t_init >= total_seconds: if times: print( f"Average framerate: {1000 / (sum(times) / len(times))}fps" ) else: print("failure") break else: t_init = time.time()
def __iter__(self): """ Run the virtual eye in a for loop frame by frame. returns the encoding and loss in a tuple by default. """ prev = ScreenWatcher.State() with display() as d: while d: if self.pred_img is not None: d.update_specific( pytorch_image_to_cv(self.pred_img) / 256.0, "pred" ) d.update_specific( self.get_screen(self.x, self.y, self.w, self.h), "grab" ) d._display_frames(d.frames) if len(d.frames) > 0: frame = d.frames[0] prev = self._update_prev(frame, prev) loss = self.train_recognizer(frame, prev.frame, prev.movement) yield tuple(self._handle_iter_yields(loss)) self.bad_actions = 0 # reset now that we've yielded prev.frame = frame.copy() self._update_focal_point() self._encode_focal_point_movement(prev) self.recognition_system.model.set_movement_data_len( prev.movement.size ) self.save()
def test_forward_edge_detect_glsl(): d = display(test_image_1, size=(1, 1)) first_frame = True edge_kernel = midget_rgc(2) kernel_height = kernel_width = 3 kernel_stride_x = kernel_stride_y = 1 kernel_padding_x = kernel_padding_y = 1 kernel_dilation_x = kernel_dilation_y = 0 width = height = None test_computer = None buffi = buffo = None while d: if d.frames: frame = next(iter(d.frames.values())) if first_frame: height = frame[0].shape[0] width = frame[0].shape[1] in_channels = frame[0].shape[2] shader_file = open( os.path.abspath(os.sep.join(['..', 'gltensors', 'shaders', 'dense_conv_forward_2d.glsl']))) simplex_shader = shader_file.read() shader_file.close() simplex_shader = glsl_import_filter(simplex_shader, os.path.abspath(os.sep.join(['..', 'gltensors', 'shaders']))) test_computer = glcpu.GLSLComputer(simplex_shader, width=width, height=height, in_channels=in_channels, out_channels=in_channels, kernel_width=kernel_width, kernel_height=kernel_height, kernel_stride_x=kernel_stride_x, kernel_stride_y=kernel_stride_y, kernel_padding_x=kernel_padding_x, kernel_padding_y=kernel_padding_y, kernel_dilation_x=kernel_dilation_x, kernel_dilation_y=kernel_dilation_y ) first_frame = False buffk = test_computer.ctx.buffer(data=edge_kernel.astype(dtype=np.float32).tobytes()) buffk.bind_to_storage_buffer(1) buffi = test_computer.ctx.buffer(data=frame[0].astype(dtype=np.float32).tobytes(), dynamic=True) buffi.bind_to_storage_buffer(0) buffo = test_computer.ctx.buffer( data=np.zeros_like(frame[0]).astype(dtype=np.float32).tobytes(), dynamic=True) buffo.bind_to_storage_buffer(2) # buffi.write(d.frames['0'][0].astype(dtype=np.float32).tobytes()) # buffo.clear() test_computer.cpu.run(height, width) edge_out = np.frombuffer(buffo.read(), dtype=np.float32).reshape((height, width, in_channels)) d.update(edge_out / edge_out.max(), 'blur') buffi.release() buffo.release()
from displayarray import display import numpy as np display(np.random.normal(0.5, 0.1, (500, 500, 3))).block()
from displayarray.effects import crop, lens from displayarray import display from examples.videos import test_video # Move the mouse to move where the crop is from on the original image display(test_video).add_callback(crop.Crop()).add_callback( lens.Barrel().enable_mouse_control()).block()
def test_backpropogate_diffs(): d = display(test_image_1, size=(1, 1)) first_frame = True edge_kernel = np.zeros_like(midget_rgc(2)) kernel_height = kernel_width = 3 kernel_stride_x = kernel_stride_y = 1 kernel_padding_x = kernel_padding_y = 1 kernel_dilation_x = kernel_dilation_y = 0 width = height = None test_computer = None buffkd = buffo = None while d: if d.frames: if first_frame: height = d.frames['0'][0].shape[0] width = d.frames['0'][0].shape[1] in_channels = d.frames['0'][0].shape[2] shader_file = open( os.path.abspath(os.sep.join(['..', 'gltensors', 'shaders', 'dense_conv_2d_backward.glsl']))) simplex_shader = shader_file.read() shader_file.close() simplex_shader = glsl_import_filter(simplex_shader, os.path.abspath(os.sep.join(['..', 'gltensors', 'shaders']))) test_computer = glcpu.GLSLComputer(simplex_shader, width=width, height=height, in_channels=in_channels, out_channels=in_channels, kernel_width=kernel_width, kernel_height=kernel_height, kernel_stride_x=kernel_stride_x, kernel_stride_y=kernel_stride_y, kernel_padding_x=kernel_padding_x, kernel_padding_y=kernel_padding_y, kernel_dilation_x=kernel_dilation_x, kernel_dilation_y=kernel_dilation_y ) first_frame = False buffk = test_computer.ctx.buffer(data=edge_kernel.astype(dtype=np.float32).tobytes()) buffk.bind_to_storage_buffer(4) buffkd = test_computer.ctx.buffer(data=edge_kernel.astype(dtype=np.float32).tobytes()) buffkd.bind_to_storage_buffer(1) buffi = test_computer.ctx.buffer( np.random.randint(0, 127, d.frames['0'][0].shape).astype(dtype=np.float32).tobytes(), dynamic=True) buffi.bind_to_storage_buffer(3) buffid = test_computer.ctx.buffer(data=np.zeros_like(d.frames['0'][0]).astype(dtype=np.float32).tobytes(), dynamic=True) buffid.bind_to_storage_buffer(0) buffod = test_computer.ctx.buffer( data=np.random.randint(0, 127, d.frames['0'][0].shape).astype(dtype=np.float32).tobytes(), dynamic=True) buffod.bind_to_storage_buffer(2) test_computer.cpu.run(height, width) ind_out = np.frombuffer(buffid.read(), dtype=np.float32).reshape((height, width, in_channels)) kd_out = np.frombuffer(buffkd.read(), dtype=np.float32).reshape(edge_kernel.shape) buffi.release() buffid.release() buffod.release()
from displayarray.effects import crop from displayarray import display import numpy as np # Scroll the mouse wheel and press ctrl, alt, or shift to select which channels are displayed as red, green, or blue. arr = np.ones((250, 250, 250)) for x in range(250): arr[..., x] = x / 250.0 display(arr).block()
from displayarray import display import numpy as np arr = np.random.normal(0.5, 0.1, (500, 500, 3)) def fix_arr_cv(arr_in): arr_in[:] += np.random.normal(0.01, 0.005, (500, 500, 3)) arr_in %= 1.0 display(arr, callbacks=fix_arr_cv, blocking=True)
from displayarray import display import numpy as np from tensorflow.keras import layers, models import tensorflow as tf from examples.videos import test_video_2 for gpu in tf.config.experimental.list_physical_devices("GPU"): tf.compat.v2.config.experimental.set_memory_growth(gpu, True) displayer = display(test_video_2) displayer.wait_for_init() autoencoder = models.Sequential() autoencoder.add( layers.Conv2D(20, (3, 3), activation="sigmoid", input_shape=displayer.frames[0].shape)) autoencoder.add( layers.Conv2D(20, (3, 3), activation="sigmoid", input_shape=displayer.frames[0].shape)) autoencoder.add(layers.Conv2DTranspose(3, (3, 3), activation="sigmoid")) autoencoder.add(layers.Conv2DTranspose(3, (3, 3), activation="sigmoid")) autoencoder.compile(loss="mse", optimizer="adam") while displayer: displayer.update() grab = tf.convert_to_tensor( next(iter(displayer.FRAME_DICT.values()))[np.newaxis, ...].astype( np.float32) / 255.0) grab_noise = tf.convert_to_tensor(
def test_display_numpy(self): from displayarray import display import numpy as np display(np.random.normal(0.5, 0.1, (500, 500, 3)))
def test_multi_cams_multi_source(self): display(0, np.random.uniform(0.0, 1.0, (500, 500)), blocking=True)
def test_multi_cams_one_source(self): display(0, window_names=["cammy", "cammy2"], blocking=True)
def test_display(self): display(np.ones((100, 100)), np.zeros((100, 100)), blocking=True)
def test_mouse_loop(self): @mouse_loop def print_mouse_thread(mouse_event): print(mouse_event) display("fractal test.mp4", blocking=True)
from displayarray.effects import crop, lens from displayarray import display from examples.videos import test_video # Move the mouse to center the image, scroll to increase/decrease barrel, ctrl+scroll to increase/decrease zoom d = (display(test_video).add_callback( lens.BarrelPyTorch().enable_mouse_control( crop_size=(256, 256))).add_callback( crop.Crop(output_size=(256, 256, 3))).wait_for_init()) while d: if len(d.frames) > 0: pass
from displayarray.effects import lens from displayarray import display from examples.videos import test_video m = lens.Mustache() m.enable_mouse_control() display(test_video, callbacks=m, blocking=True)
from displayarray import display import math as m from examples.videos import test_video def forest_color(arr): forest_color.i += 1 arr[..., 0] = (m.sin(forest_color.i * (2 * m.pi) * 0.4 / 360) * 255 + arr[..., 0]) % 255 arr[..., 1] = (m.sin( (forest_color.i * (2 * m.pi) * 0.5 + 45) / 360) * 255 + arr[..., 1]) % 255 arr[..., 2] = (m.cos(forest_color.i * (2 * m.pi) * 0.3 / 360) * 255 + arr[..., 2]) % 255 forest_color.i = 0 display(test_video, callbacks=forest_color, blocking=True, fps_limit=120)
def test_denoise_cpu(): d = display(test_image_1, size=(1, 1), fps_limit=240) edge_kernel = -np.random.randint( -127, 127, (3, 3, 3, 3)).astype(dtype=np.float32) / 127.0 kernel_height = kernel_width = 3 kernel_stride_x = kernel_stride_y = 1 kernel_padding_x = kernel_padding_y = 1 kernel_dilation_x = kernel_dilation_y = 0 first_frame = True width = height = None forward_computer = backward_computer = None buffkd = buffo = None in_channels = None kd_out_prev = None while d: if d.frames: frame = next(iter(d.frames.values()))[0].astype(np.float32) / 256.0 noise = np.random.randint( 0, 256, frame.shape).astype(dtype=np.float32) / 256.0 noised_frame = frame + noise d.update(noised_frame, 'noised frame') if first_frame: height = frame.shape[0] width = frame.shape[1] in_channels = frame.shape[2] shader_file = open( os.path.abspath( os.sep.join([ '..', 'gltensors', 'shaders', 'dense_conv_forward_2d.glsl' ]))) forward_shader = shader_file.read() shader_file.close() shader_file = open( os.path.abspath( os.sep.join([ '..', 'gltensors', 'shaders', 'dense_conv_2d_backward.glsl' ]))) backward_shader = shader_file.read() shader_file.close() forward_computer = glcpu.GLSLComputer( forward_shader, width=width, height=height, in_channels=in_channels, out_channels=in_channels, kernel_width=kernel_width, kernel_height=kernel_height, kernel_stride_x=kernel_stride_x, kernel_stride_y=kernel_stride_y, kernel_padding_x=kernel_padding_x, kernel_padding_y=kernel_padding_y, kernel_dilation_x=kernel_dilation_x, kernel_dilation_y=kernel_dilation_y) backward_computer = glcpu.GLSLComputer( backward_shader, width=width, height=height, in_channels=in_channels, out_channels=in_channels, kernel_width=kernel_width, kernel_height=kernel_height, kernel_stride_x=kernel_stride_x, kernel_stride_y=kernel_stride_y, kernel_padding_x=kernel_padding_x, kernel_padding_y=kernel_padding_y, kernel_dilation_x=kernel_dilation_x, kernel_dilation_y=kernel_dilation_y) first_frame = False forward_computer = glcpu.GLSLComputer( forward_shader, width=width, height=height, in_channels=in_channels, out_channels=in_channels, kernel_width=kernel_width, kernel_height=kernel_height, kernel_stride_x=kernel_stride_x, kernel_stride_y=kernel_stride_y, kernel_padding_x=kernel_padding_x, kernel_padding_y=kernel_padding_y, kernel_dilation_x=kernel_dilation_x, kernel_dilation_y=kernel_dilation_y) buffk_f = forward_computer.ctx.buffer(data=edge_kernel.astype( dtype=np.float32).tobytes()) buffk_f.bind_to_storage_buffer(1) buffi_f = forward_computer.ctx.buffer(data=frame.astype( dtype=np.float32).tobytes()) buffi_f.bind_to_storage_buffer(0) buffo_f = forward_computer.ctx.buffer( data=np.zeros_like(frame).astype(dtype=np.float32).tobytes()) buffo_f.bind_to_storage_buffer(2) forward_computer.cpu.run(height, width) forward_computer.ctx.finish() out_img = np.frombuffer(buffo_f.read(), dtype=np.float32).reshape( (height, width, in_channels)) if np.average(out_img) < 0: print("out img -1") d.update(-out_img, 'out img') else: d.update(out_img, 'out img') out_error = out_img - frame buffk_f.release() buffi_f.release() buffo_f.release() forward_computer.ctx.release() backward_computer = glcpu.GLSLComputer( backward_shader, width=width, height=height, in_channels=in_channels, out_channels=in_channels, kernel_width=kernel_width, kernel_height=kernel_height, kernel_stride_x=kernel_stride_x, kernel_stride_y=kernel_stride_y, kernel_padding_x=kernel_padding_x, kernel_padding_y=kernel_padding_y, kernel_dilation_x=kernel_dilation_x, kernel_dilation_y=kernel_dilation_y) buffk_b = backward_computer.ctx.buffer(data=edge_kernel.astype( dtype=np.float32).tobytes()) buffk_b.bind_to_storage_buffer(8) buffkd = backward_computer.ctx.buffer( data=np.zeros_like(edge_kernel).astype( dtype=np.float32).tobytes()) buffkd.bind_to_storage_buffer(5) buffi_b = backward_computer.ctx.buffer( frame.astype(dtype=np.float32).tobytes()) buffi_b.bind_to_storage_buffer(7) buffid = backward_computer.ctx.buffer( data=np.zeros_like(frame).astype(dtype=np.float32).tobytes()) buffid.bind_to_storage_buffer(4) buffod = backward_computer.ctx.buffer(data=out_error.astype( dtype=np.float32).tobytes()) buffod.bind_to_storage_buffer(6) backward_computer.cpu.run(height, width) backward_computer.ctx.finish() ind_out = np.frombuffer(buffid.read(), dtype=np.float32).reshape( (height, width, in_channels)) kd_out = np.frombuffer(buffkd.read(), dtype=np.float32).reshape(edge_kernel.shape) if np.average(out_error) < 0: print("out_error -1") d.update(-out_error, 'out err') else: d.update(out_error, 'out err') if np.average(ind_out) < 0: print("ind_out -1") d.update(-ind_out, 'in err') else: d.update(ind_out, 'in err') #print(kd_out) if kd_out_prev is not None: err_vel = np.abs(kd_out - kd_out_prev) err_vel = np.max(err_vel, 1) else: err_vel = np.ones_like(kd_out) kd_out_prev = kd_out #print(err_vel) d_half = (np.average(np.abs(kd_out))) err_1 = ((kd_out) / d_half) err_clip = np.abs(np.clip(err_1, -.5, .5)) err_copy = kd_out.copy() err_copy[err_clip != .5] = 0 v_half = (np.average(np.abs(err_vel))) err_vel_1 = ((err_vel) / v_half) err_vel_clip = np.abs(np.clip(err_vel_1, -.5, .5)) err_vel[err_vel_clip != .5] = 0 # velocity weighted adagrad. eta = 1.0 eta_vel = 1.0e-1 err_min_1 = np.where( err_copy != 0, np.divide(np.abs(edge_kernel), np.sqrt(np.abs(err_copy)), where=err_copy != 0), 0) * np.sign(err_copy) err_min_2 = np.where( err_vel != 0, np.divide(np.abs(edge_kernel), np.sqrt(np.abs(err_vel)), where=err_vel != 0), 0) * np.sign(err_vel) print(np.average(err_min_1)) err_minus = eta * err_min_1 + err_min_2 * eta_vel edge_kernel -= err_minus #print(err_vel_1) buffi_b.release() buffk_b.release() buffkd.release() buffid.release() buffod.release() backward_computer.ctx.release()
from displayarray.effects import crop, lens from displayarray import display from examples.videos import test_video import math as m # Move the mouse to center the image, scroll to increase/decrease barrel, ctrl+scroll to increase/decrease zoom pre_crop_callback = crop.Crop(output_size=(480, 640, 3)).enable_mouse_control() lens_callback = lens.BarrelPyTorch() post_crop_callback = crop.Crop(output_size=(256, 256, 3)).enable_mouse_control() d = (display( 0, size=(99999, 99999)).add_callback(pre_crop_callback).add_callback( lens_callback).add_callback(post_crop_callback).wait_for_init()) i = 0 while d: if len(d.frames) > 0: i += 1 frame = d.frames[0] center_sin = [(m.sin(m.pi * (i / 70.0))), (m.cos(m.pi * (i / 120.0)))] pre_crop_callback.center = [ center_sin[0] * 720 / 2 + 720 / 2, center_sin[1] * 1280 / 2 + 1280 / 2, ] lens_callback.center = [ center_sin[0] * 480 / 2 + 480 / 2, center_sin[1] * 640 / 2 + 640 / 2, ] post_crop_callback.center = [480 / 2, 640 / 2]