From cb69732f68c0bd46c1574de16ce1aee6f38e439b Mon Sep 17 00:00:00 2001 From: Brett Weiland Date: Tue, 11 Jun 2024 14:50:14 -0500 Subject: restarting --- collective/.gpu_migration.py.swo | Bin 0 -> 20480 bytes collective/.gpu_migration.py.swp | Bin 0 -> 16384 bytes collective/.kernel.c.swp | Bin 0 -> 12288 bytes collective/gpu_migration.py | 165 +++++++++++++++++++++++++++++++++++++++ collective/kernel.c | 116 +++++++++++++++++++++++++++ collective/mask.png | 1 + collective/notes | 79 +++++++++++++++++++ collective/out.png | Bin 0 -> 3981166 bytes collective/out_grad.png | Bin 0 -> 3387948 bytes collective/out_texture.png | Bin 0 -> 1907188 bytes collective/texput.log | 21 +++++ 11 files changed, 382 insertions(+) create mode 100644 collective/.gpu_migration.py.swo create mode 100644 collective/.gpu_migration.py.swp create mode 100644 collective/.kernel.c.swp create mode 100755 collective/gpu_migration.py create mode 100644 collective/kernel.c create mode 120000 collective/mask.png create mode 100644 collective/notes create mode 100644 collective/out.png create mode 100644 collective/out_grad.png create mode 100644 collective/out_texture.png create mode 100644 collective/texput.log (limited to 'collective') diff --git a/collective/.gpu_migration.py.swo b/collective/.gpu_migration.py.swo new file mode 100644 index 0000000..4806821 Binary files /dev/null and b/collective/.gpu_migration.py.swo differ diff --git a/collective/.gpu_migration.py.swp b/collective/.gpu_migration.py.swp new file mode 100644 index 0000000..bc46962 Binary files /dev/null and b/collective/.gpu_migration.py.swp differ diff --git a/collective/.kernel.c.swp b/collective/.kernel.c.swp new file mode 100644 index 0000000..7e1f62d Binary files /dev/null and b/collective/.kernel.c.swp differ diff --git a/collective/gpu_migration.py b/collective/gpu_migration.py new file mode 100755 index 0000000..9536561 --- /dev/null +++ b/collective/gpu_migration.py @@ -0,0 +1,165 @@ +#!/usr/bin/env python3 +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.animation as animation +import matplotlib.style as mplstyle +import pyopencl as cl +from alive_progress import alive_bar +from matplotlib.backend_bases import MouseButton +from PIL import Image + +# HELLO READER ------------------------------------------------------------------------ +# yes, I know this script is horrid, but it's more of a scratchpad to quickly test ideas +# and not anything I'm ever going to show anyone else. + +img_res_x = 1000 +img_res_y = 1000 +total_pixels = img_res_x * img_res_y # so we don't gotta compute it every time + +periods = 1 +square_x = 0 +square_y = -2 + +escape = 10000 +iterations = (255*3) +c_x = 2 * np.pi +c_y = 2 * np.pi + +animation_progres_save = "ani1_less.mp4" +single_frame_save = "asdf.png" + +opencl_context = cl.create_some_context(interactive=False) +opencl_queue = cl.CommandQueue(opencl_context) + +kernel_src_path = "./kernel.c" + +frames = 1 +rendered_frames = [] + +image = np.empty([img_res_x, img_res_y], np.double) + +plt.style.use('dark_background') +# fuck this shit +fig = plt.figure(frameon=False) +fig.set_size_inches(img_res_x/fig.dpi, img_res_y/fig.dpi) +#fig.set_size_inches(width/height, 1, forward=False) + + +ax = plt.Axes(fig, [0., 0., 1., 1.]) + +manual_limits = [15.832664460420503, + 16.161782579162786, + 0.21263776938088172, + 0.2668613889327035] + + +#ax.invert_yaxis() +ax.set_xlim((-periods * np.pi) + (square_x * np.pi), (periods * np.pi) + (square_x * np.pi)) +ax.set_ylim((-periods * np.pi) + (square_y * np.pi), (periods * np.pi) + (square_y * np.pi)) +#ax.set_xlim(manual_limits[0], manual_limits[1]) +#ax.set_ylim(manual_limits[2], manual_limits[3]) + +#ax.set_axis_off() +fig.add_axes(ax) +mplstyle.use('fast') + +cmap = plt.cm.viridis +cmap.set_bad((0,0,0)) +cmap.set_over((0,0,0)) +cmap.set_under((0,0,0)) + + + + +print("compiling openCL kernel...") +with open(kernel_src_path, 'r') as kernel_src: + compiled_kernel = cl.Program(opencl_context, kernel_src.read()).build() + +encoding_progress = alive_bar(frames, bar = 'filling', spinner = 'waves') + +def display_encoder_progress(current_frame: int, total_frames: int): + print("Encoding: frame {}/{}".format(current_frame, frames)) + +temp_render_hook = False +mp_image = None + +def render(axes): + global temp_render_hook + global mp_image + if not temp_render_hook: + temp_render_hook = True + x_min = axes.get_xlim()[0] + x_max = axes.get_xlim()[1] + y_min = axes.get_ylim()[1] + y_max = axes.get_ylim()[0] + print(axes.get_ylim()) + compiled_kernel.render_frame_curvature(opencl_queue, image.shape, None, image_buffer, mask_buffer, + np.double(abs(x_max - x_min) / img_res_x), + np.double(abs(y_max - y_min) / img_res_y), + np.double(x_min), np.double(y_min), + np.uint32(iterations), np.uint32(escape), + np.double(1)) + cl.enqueue_copy(opencl_queue, image, image_buffer).wait() + print("kernel") + if mp_image == None: + mp_image = ax.imshow(image, norm="linear", aspect="auto", cmap=cmap, interpolation='none', extent=(x_min, x_max, y_min, y_max)) # TODO + else: + mp_image.set(extent=(x_min, x_max, y_min, y_max)) + #ax.set_aspect('equal') + #mp_image.set_data(image) + mp_image.set_array(image) + + + fig.canvas.draw_idle() + fig.canvas.flush_events() + temp_render_hook = False + +#plt.ion() + +#open image +mask_path = "mask.png" +mask = np.asarray(Image.open(mask_path).convert("L").resize((img_res_x, img_res_y)), dtype=np.double) +#mask = np.zeros((img_res_x, img_res_y), dtype=np.double) +mask.setflags(write=1) +mask /= np.max(mask) # normalize +#print(mask.shape) +#print(mask.dtype) +#print(mask) +#ax.imshow(mask, norm="linear") +#plt.show() + +image_buffer = cl.Buffer(opencl_context, cl.mem_flags.WRITE_ONLY, image.nbytes) +mask_buffer = cl.Buffer(opencl_context, cl.mem_flags.READ_ONLY, mask.nbytes) +cl.enqueue_copy(opencl_queue, mask_buffer, mask).wait() +#mask_buffer = cl.array.Array(opencl_context,mask.shape, dtype=np.uint8, data=mask) + +#move to render +print("Rendering {} frames...".format(frames)) +if frames > 1: + x_min = ax.get_xlim()[0] + x_max = ax.get_xlim()[1] + y_min = ax.get_ylim()[1] + y_max = ax.get_ylim()[0] + with alive_bar(frames, bar = 'filling', spinner = 'waves') as bar_total: + for frame_i in range(0, frames): + compiled_kernel.render_frame_curvature(opencl_queue, image.shape, None, image_buffer, mask_buffer, + np.double(abs(x_max - x_min) / img_res_x), + np.double(abs(y_max - y_min) / img_res_y), + np.double(x_min), np.double(y_min), + np.uint32(iterations), np.uint32(escape), + np.double(frame_i/frames)) + + + cl.enqueue_copy(opencl_queue, image, image_buffer).wait() + rendered_frame = ax.imshow(image, norm="linear", aspect="auto", cmap=cmap, animated="True") + rendered_frames.append([rendered_frame]) + bar_total() + print("Encoding/Saving...") + ani = animation.ArtistAnimation(fig, rendered_frames, interval=30, blit=True) + ani.save(animation_progres_save, extra_args=['-preset', 'lossless'], progress_callback=display_encoder_progress, codec="h264_nvenc") +else: + ax.callbacks.connect('ylim_changed', render) + ax.callbacks.connect('xlim_changed', render) + render(ax) + plt.savefig("out_texture.png") + plt.show(block=True) diff --git a/collective/kernel.c b/collective/kernel.c new file mode 100644 index 0000000..f3982a6 --- /dev/null +++ b/collective/kernel.c @@ -0,0 +1,116 @@ +//#include +#define PI 3.141592653589793115997963468544185161590576171875 + +double cosecant_single(double a, double b) { return a / cos(b); } +double secant_single(double a, double b) { return a / cos(b); } + +/** +__kernel void render_frame_orbit_trap(__global double *frame_output, __global double *mask, + double x_step, double y_step, + double x_start, double y_start, + unsigned int iterations, unsigned int escape, double ratio) { + + const vec2 point = (0, 0); + + unsigned int result; + unsigned int iter; + + double min_distance = DBL_MAX; + + for(iter = 0; iter < iterations; iter++) { + double next_x; + double r = mask[img_index]; + next_x = (r * cosecant_single(x, y)) + ((1 - r) * secant_single(x, y)); + y = (r * cosecant_single(y, x)) + ((1 - r) * secant_single(y, x)); + x = next_x; + if((pow(x, 2) + pow(y, 2)) >= escape) break; + } + + frame_output[img_index] = total_curve / iter; + +} +**/ + + +__kernel void render_frame_curvature(__global double *frame_output, __global double *mask, + double x_step, double y_step, + double x_start, double y_start, + unsigned int iterations, unsigned int escape, double ratio) { + unsigned int result; + unsigned int iter; + + double x_cart = (get_global_id(0) * x_step) + x_start; + double y_cart = (get_global_id(1) * y_step) + y_start; + double x = sqrt(pow(x_cart, 2) + pow(y_cart, 2)); + double y = atan(y_cart / x_cart); + + //double x = (get_global_id(0) * x_step) + x_start; + //double y = (get_global_id(1) * y_step) + y_start; + size_t img_index = (get_global_id(1) * get_global_size(1)) + get_global_id(0); + + double total_curve = 0; + + //just found out vectors are a thing + double2 lp[3]; + + for(iter = 0; iter < iterations; iter++) { + double next_x; + double r = mask[img_index]; + next_x = (r * secant_single(x, y)) + ((1 - r) * cosecant_single(x, y)); + y = (r * secant_single(y, x)) + ((1 - r) * cosecant_single(y, x)); + x = next_x; + + if((pow(x, 2) + pow(y, 2)) >= escape) break; + lp[2] = lp[1]; + lp[1] = lp[0]; + lp[0] = (double2)(x, y); //why do I have to cast this? hope no accuracy lost + + /** + if(img_index == 254234) { + printf("%u\n", ratio); + } + **/ + if(iter >= 2) { + double curl = acos(dot((lp[0] - lp[1]), (lp[2] - lp[1])) / (distance(lp[0], lp[1]) * distance(lp[2], lp[1]))); + total_curve = (total_curve + curl); + } + } + frame_output[img_index] = total_curve / iter; +} + + +__kernel void render_frame(__global double *frame_output, __global double *mask, + double x_step, double y_step, + double x_start, double y_start, + unsigned int iterations, unsigned int escape, double ratio) { + unsigned int result; + double x_cart = (get_global_id(0) * x_step) + x_start; + double y_cart = (get_global_id(1) * y_step) + y_start; + size_t img_index = (get_global_id(1) * get_global_size(1)) + get_global_id(0); + + double x = sqrt(pow(x_cart, 2) + pow(y_cart, 2)); + double y = atan(y_cart / x_cart); + + //double x = (get_global_id(0) * x_step) + x_start; + //double y = (get_global_id(1) * y_step) + y_start; + + + unsigned int iter; + + //vec2 pos; + + for(iter = 0; iter < iterations; iter++) { + double next_x; + double r = ratio; + next_x = (r * cosecant_single(x, y)) + ((1 - r) * secant_single(x, y)); + y = (r * cosecant_single(y, x)) + ((1 - r) * secant_single(y, x)); + x = next_x; + //if(distance(pos) >= escape) break; + if((pow(x, 2) + pow(y, 2)) >= escape) break; + } + + + //TODO turn back to int whenever + frame_output[img_index] = (double)iter; + //frame_output[img_index] = mask[img_index] * 255; +} diff --git a/collective/mask.png b/collective/mask.png new file mode 120000 index 0000000..afb5f75 --- /dev/null +++ b/collective/mask.png @@ -0,0 +1 @@ +../masks/clouds.png \ No newline at end of file diff --git a/collective/notes b/collective/notes new file mode 100644 index 0000000..50249d7 --- /dev/null +++ b/collective/notes @@ -0,0 +1,79 @@ +#!/usr/bin/env python3 +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.animation as animation +import pyopencl as cl +from alive_progress import alive_bar + +img_res_x = 2000 +img_res_y = 2000 +total_pixels = img_res_x * img_res_y # so we don't gotta compute it every time + +periods = 1 +square_x = 0 +square_y = 0 + +xmin = (-periods * np.pi) + (square_x * np.pi) +xmax = (periods * np.pi) + (square_x * np.pi) +ymin = (-periods * np.pi) + (square_y * np.pi) +ymax = (periods * np.pi) + (square_y * np.pi) + +escape = 10000 +iterations = 255*3 +c_x = 2 * np.pi +c_y = 2 * np.pi + +animation_progres_save = "./animations" +frames = 120 + +rendered_frames = [] + + +plt.style.use('dark_background') +# fuck this shit +fig = plt.figure(frameon=False) +fig.set_size_inches(img_res_x/fig.dpi, img_res_y/fig.dpi) +#fig.set_size_inches(width/height, 1, forward=False) + +ax = plt.Axes(fig, [0., 0., 1., 1.]) +ax.set_axis_off() +fig.add_axes(ax) + +cmap = plt.cm.viridis +cmap.set_bad((0,0,0)) +cmap.set_over((0,0,0)) +cmap.set_under((0,0,0)) + +opencl_context = cl.create_some_context() +opencl_queue = cl.CommandQueue(opencl_context) + + +#def render(): +# image = np.empty([img_res_y, img_res_x]) +# print("Rendering frames") +# with alive_bar(frames, bar = 'filling', spinner = 'waves') as bar_total: +# for frame in range(frames): +# split_ratio = frame / frames +# for pix_y, y in enumerate(np.linspace(ymin, ymax, img_res_y)): +# for pix_x, x in enumerate(np.linspace(xmin, xmax, img_res_x)): +# on_x = x +# on_y = y +# for i in range(iterations): +# next_x = (split_ratio * (on_x/np.sin(on_y))) + ((1 - split_ratio) * on_x/np.tan(on_y)) +# on_y = (split_ratio * (on_y/np.sin(on_x))) + ((1 - split_ratio) * on_y/np.tan(on_x)) +# on_x = next_x +# if on_x**2 + on_y**2 > escape: +# break +# image[pix_y][pix_x] = i +# rendered_frame = ax.imshow(image, norm="log", aspect="auto", cmap=cmap, animated=False) +# rendered_frames.append([rendered_frame]) +# bar_total() + +def display(): + print(rendered_frames) + ani = animation.ArtistAnimation(fig, rendered_frames, interval=30, blit=True) + ani.save("test.mp4") + plt.show() + +render() +display() diff --git a/collective/out.png b/collective/out.png new file mode 100644 index 0000000..5011695 Binary files /dev/null and b/collective/out.png differ diff --git a/collective/out_grad.png b/collective/out_grad.png new file mode 100644 index 0000000..26fb1f1 Binary files /dev/null and b/collective/out_grad.png differ diff --git a/collective/out_texture.png b/collective/out_texture.png new file mode 100644 index 0000000..8031ab1 Binary files /dev/null and b/collective/out_texture.png differ diff --git a/collective/texput.log b/collective/texput.log new file mode 100644 index 0000000..d13b81a --- /dev/null +++ b/collective/texput.log @@ -0,0 +1,21 @@ +This is pdfTeX, Version 3.141592653-2.6-1.40.26 (TeX Live 2024/Arch Linux) (preloaded format=pdflatex 2024.4.22) 28 APR 2024 21:33 +entering extended mode + restricted \write18 enabled. + %&-line parsing enabled. +** + +! Emergency stop. +<*> + +End of file on the terminal! + + +Here is how much of TeX's memory you used: + 3 strings out of 476076 + 113 string characters out of 5793775 + 1925187 words of memory out of 5000000 + 22212 multiletter control sequences out of 15000+600000 + 558069 words of font info for 36 fonts, out of 8000000 for 9000 + 14 hyphenation exceptions out of 8191 + 0i,0n,0p,13b,6s stack positions out of 10000i,1000n,20000p,200000b,200000s +! ==> Fatal error occurred, no output PDF file produced! -- cgit v1.2.3