summaryrefslogtreecommitdiff
path: root/collective
diff options
context:
space:
mode:
Diffstat (limited to 'collective')
-rw-r--r--collective/.gpu_migration.py.swobin0 -> 20480 bytes
-rw-r--r--collective/.gpu_migration.py.swpbin0 -> 16384 bytes
-rw-r--r--collective/.kernel.c.swpbin0 -> 12288 bytes
-rwxr-xr-xcollective/gpu_migration.py165
-rw-r--r--collective/kernel.c116
l---------collective/mask.png1
-rw-r--r--collective/notes79
-rw-r--r--collective/out.pngbin0 -> 3981166 bytes
-rw-r--r--collective/out_grad.pngbin0 -> 3387948 bytes
-rw-r--r--collective/out_texture.pngbin0 -> 1907188 bytes
-rw-r--r--collective/texput.log21
11 files changed, 382 insertions, 0 deletions
diff --git a/collective/.gpu_migration.py.swo b/collective/.gpu_migration.py.swo
new file mode 100644
index 0000000..4806821
--- /dev/null
+++ b/collective/.gpu_migration.py.swo
Binary files differ
diff --git a/collective/.gpu_migration.py.swp b/collective/.gpu_migration.py.swp
new file mode 100644
index 0000000..bc46962
--- /dev/null
+++ b/collective/.gpu_migration.py.swp
Binary files differ
diff --git a/collective/.kernel.c.swp b/collective/.kernel.c.swp
new file mode 100644
index 0000000..7e1f62d
--- /dev/null
+++ b/collective/.kernel.c.swp
Binary files 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 <math.h>
+#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
--- /dev/null
+++ b/collective/out.png
Binary files differ
diff --git a/collective/out_grad.png b/collective/out_grad.png
new file mode 100644
index 0000000..26fb1f1
--- /dev/null
+++ b/collective/out_grad.png
Binary files differ
diff --git a/collective/out_texture.png b/collective/out_texture.png
new file mode 100644
index 0000000..8031ab1
--- /dev/null
+++ b/collective/out_texture.png
Binary files 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!
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-23 13:30:55 +0000