diff --git a/Untitled-1.ipynb b/example.ipynb similarity index 63% rename from Untitled-1.ipynb rename to example.ipynb index 1d31237..1861e27 100644 --- a/Untitled-1.ipynb +++ b/example.ipynb @@ -1,5 +1,150 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pip install -q git+https://github.com/cpgoodri/jax_transformations3d.git" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import jax\n", + "from jax import jit, vmap\n", + "from functools import partial\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", + "import jax_transformations3d as jts\n", + "import colorsys\n", + "import numpy as np\n", + "import math\n", + "import time\n", + "from tqdm.auto import tqdm, trange\n", + "\n", + "from raytrace import *" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [], + "source": [ + "# bounce count, time\n", + "# 4, 31,\n", + "# 8, 61.3, 71\n", + "# 16, 121-122\n", + "\n", + "sphere_pos, sphere_radius, mat_color, em_color, em_strength, mat = stack_dict_list(\n", + " spheres\n", + ")\n", + "\n", + "key = jax.random.PRNGKey(0)\n", + "result_img = jnp.zeros((res_y, res_x, 3))\n", + "\n", + "# this should be before every ray trace, but for now keep it here\n", + "x_offset, y_offset = (jax.random.uniform(subkey, (2,)) - 0.5) * 0.005\n", + "ray_pos, ray_dirs = get_init(\n", + " res_x, res_y, x_persp, y_persp, camera_persp, x_offset, y_offset\n", + ")\n", + "#\n", + "\n", + "result_img.block_until_ready()\n", + "t0 = time.time()\n", + "\n", + "k = 10\n", + "for i in range(k):\n", + " key, subkey = jax.random.split(key, 2)\n", + " key_grid = jax.random.split(subkey, res_x * res_y).reshape((res_x, res_y, -1))\n", + "\n", + " result_img += full_ray_trace(\n", + " ray_pos,\n", + " ray_dirs,\n", + " key_grid,\n", + " sphere_pos,\n", + " sphere_radius,\n", + " mat_color,\n", + " em_color,\n", + " em_strength,\n", + " mat,\n", + " )\n", + "\n", + "result_img.block_until_ready()\n", + "print((time.time() - t0) * 1000)\n", + "\n", + "plt.imshow(result_img / jnp.quantile(result_img.flatten(), 0.95))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "base_res = 256\n", + "x_persp, y_persp = 1.5 * 3, 1 * 3\n", + "res_x, res_y = int(base_res * x_persp), int(base_res * y_persp)\n", + "camera_persp = 12\n", + "\n", + "\n", + "n = 5\n", + "spheres = [\n", + " {\n", + " \"pos\": [5, -5 + l * 10, 0],\n", + " \"radius\": 1,\n", + " \"mat_color\": colorsys.hls_to_rgb(l * (1 - 1 / n), 0.5, 1),\n", + " \"em_color\": colorsys.hls_to_rgb(l * (1 - 1 / n), 0.5, 1),\n", + " \"em_strength\": 0,\n", + " \"mat\": max(l, 0.01),\n", + " }\n", + " for l in jnp.linspace(0, 1, n)\n", + "] + [\n", + " # {'pos': [10000+15, 0, 0], 'radius': 10000, 'mat_color': [1, 1, 1], 'em_color': [1, 1, 1], 'em_strength': 0.01, 'mat': 0.5},\n", + " # ground\n", + " {\n", + " \"pos\": [5, 0, 40000],\n", + " \"radius\": 40000 - 1,\n", + " \"mat_color\": [1, 1, 1],\n", + " \"em_color\": [1, 1, 1],\n", + " \"em_strength\": 0,\n", + " \"mat\": 1,\n", + " },\n", + " # back wall\n", + " # {'pos': [40000, 0, 0], 'radius': 40000-100, 'mat_color': [0.1, .1, 0.1], 'em_color': [1, 1, 1], 'em_strength': 0, 'mat': 1},\n", + " # ceiling light\n", + " {\n", + " \"pos\": [5, 0, -40000],\n", + " \"radius\": 40000 - 5000,\n", + " \"mat_color\": [1, 1, 1],\n", + " \"em_color\": [1, 1, 1],\n", + " \"em_strength\": 0.000001,\n", + " \"mat\": 1,\n", + " },\n", + " # {'pos': [10, 5, -5], 'radius': 4, 'mat_color': [1, 1, 1], 'em_color': [1, 1, 1], 'em_strength': 0, 'mat': 0},\n", + " # {'pos': [5-math.sin(math.pi*i*2)*10, math.cos(math.pi*i*2)*10, -4], 'radius': 1, 'mat_color': [0, 0, 0], 'em_color': [1, 1, 1], 'em_strength': 3, 'mat': 1},\n", + " # {'pos': [6, -10, 0], 'radius': 0.5, 'mat_color': [0, 0, 0], 'em_color': [0, 0.5, 1], 'em_strength': 40, 'mat': 1},\n", + "]" + ] + }, { "cell_type": "code", "execution_count": null, @@ -34,7 +179,7 @@ " mat,\n", " )\n", "\n", - " return result_img\n" + " return result_img" ] }, { @@ -86,7 +231,7 @@ " # result_img = result_img.at[:400].set(0)\n", " # plt.imshow(result_img/result_img[300:].mean(axis=-1).max()*16, interpolation='none')\n", " # plt.show()\n", - " images.append(result_img)\n" + " images.append(result_img)" ] }, { @@ -135,7 +280,7 @@ "plt.figure(figsize=(15, 15))\n", "# result_img = result_img.at[:400].set(0)\n", "plt.imshow(result_img / result_img[300:].mean(axis=-1).max(), interpolation=\"none\")\n", - "plt.show()\n" + "plt.show()" ] }, { @@ -152,18 +297,11 @@ "\n", "cpus = jax.devices(\"cpu\")\n", "results = jnp.stack([jax.device_put(r, cpus[0]) for r in results])\n", - "\n", - "\n", - "\n", - "\n", "images_procs = jnp.stack(images)\n", - "\n", - "\n", "max_v = jnp.quantile(images_procs[:, 250:].flatten(), 0.95)\n", - "\n", "images_procs = (images_procs / max_v * 255).astype(jnp.uint8)\n", "\n", - "imageio.mimsave(\"video.mp4\", list(images_procs) * 2, fps=20)\n" + "imageio.mimsave(\"video.mp4\", list(images_procs) * 2, fps=20)" ] }, { @@ -208,7 +346,7 @@ " \"em_strength\": 40,\n", " \"mat\": 1,\n", " },\n", - "]\n" + "]" ] }, { @@ -228,30 +366,29 @@ " normal_result = jnp.take_along_axis(normal, indices=closest_hit[..., None, None], axis=-1).squeeze()\n", "\n", " return did_hit_result, dst_result, hit_point_result, normal_result\n", - "\"\"\"\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "\n", - "t = time.time()\n", - "dist, hit_point, normal = ray_trace_iter(ray_pos, ray_dirs, sphere_pos, sphere_radius)\n", - "print(dist.sum())\n", - "print(time.time() - t)\n" + "\"\"\"" ] } ], "metadata": { - "language_info": { - "name": "python" + "kernelspec": { + "display_name": "jax-tf", + "language": "python", + "name": "jax-tf" }, - "orig_nbformat": 4 + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/raytrace.py b/raytrace.py new file mode 100644 index 0000000..384c082 --- /dev/null +++ b/raytrace.py @@ -0,0 +1,131 @@ +from functools import partial + +import jax +import jax.numpy as jnp +from jax import jit, vmap + + +def ray_intersect(ray_origin, ray_dir, sphere_center, sphere_radius): + # ray_dir should be normalized + offset_ray_origin = ray_origin - sphere_center + a = jnp.dot(ray_dir, ray_dir) + b = 2 * jnp.dot(offset_ray_origin, ray_dir) + c = jnp.dot(offset_ray_origin, offset_ray_origin) - sphere_radius**2 + + discriminant = b**2 - 4 * a * c + dist = (-b - jnp.sqrt(discriminant)) / (2 * a) + + # sphere was hit if (discriminant >= 0) & (dist >= 0) + # if discriminant < 0, then dist is nan already, if dist < 0, + # meaning hitpoint is against ray direction, set dist to nan + dist = jnp.where(dist < 0, jnp.nan, dist) + + return dist + + +def ray_intersect_target_batch(ray_origin, ray_dir, sphere_center, sphere_radius): + dist = ray_intersect(ray_origin, ray_dir, sphere_center, sphere_radius) + closest_hit = jnp.nanargmin(dist) + dist = dist[closest_hit] + + return dist, closest_hit + + +@jit +@partial(vmap, in_axes=(1, 1, 1, None, None, None, None, None, None)) +@partial(vmap, in_axes=(0, 0, 0, None, None, None, None, None, None)) +def full_ray_trace( + ray_origin, + ray_dir, + key, + sphere_center, + sphere_radius, + mat_color, + em_color, + em_strength, + mat, +): + def ray_trace_single_hit(args): + inc_light, ray_color, ray_origin, ray_dir, key, i, done = args + dist, closest_hit = ray_intersect_target_batch( + ray_origin, ray_dir, sphere_center, sphere_radius + ) + did_hit = ~jnp.isnan(dist) # or: closest_hit != -1 + # done = done | (did_hit & (em_strength[closest_hit] == 1) & (jnp.arange(10)[i] == 0)) + # did_hit = did_hit & ~done + + hit_point = ray_origin + ray_dir * dist + normal = hit_point - sphere_center[closest_hit] + normal = normal / jnp.linalg.norm(normal) + + emitted_light = em_color[closest_hit] * em_strength[closest_hit] + light_strength = jnp.dot(normal, -ray_dir) + light_strength = jnp.where(jnp.isnan(light_strength), 0, light_strength) + inc_light += did_hit * (emitted_light * ray_color) + # *light_strength + ray_color = ( + did_hit * ray_color * mat_color[closest_hit] + (~did_hit) * ray_color + ) + + key, subkey = jax.random.split(key, 2) + random_dir = jax.random.normal(subkey, (3,)) + random_dir = random_dir / jnp.linalg.norm(random_dir) + diffuse_reflect = random_dir * jnp.sign(jnp.dot(random_dir, normal)) + diffuse_reflect = diffuse_reflect / jnp.linalg.norm(diffuse_reflect) + + specular_reflect = ( + ray_dir - 2 * jnp.dot(ray_dir, normal) * normal + ) # maybe should be -raydir too? + specular_reflect = specular_reflect / jnp.linalg.norm(specular_reflect) + + alpha = mat[closest_hit] + reflect_dir = alpha * diffuse_reflect + (1 - alpha) * specular_reflect + + return inc_light, ray_color, hit_point, reflect_dir, key, i + 1, done | ~did_hit + + inc_light = jnp.zeros((3,)) + ray_color = jnp.ones((3,)) + + # inc_light, ray_color, _, _, _ = ray_trace_single_hit(inc_light, ray_color, ray_origin, ray_dir, key) + + def cond_fun(args): + i = args[-2] + done = args[-1] + return (i < 8) | done + + inc_light, ray_color, _, _, _, _, _ = jax.lax.while_loop( + cond_fun, + ray_trace_single_hit, + (inc_light, ray_color, ray_origin, ray_dir, key, 0, False), + ) + return inc_light + + +# coordinates are (x, y, z) +# x is forward backward +# y is left right +# z is up down + + +def stack_dict_list(l): + keys = l[0].keys() + return [jnp.stack([jnp.array(elm[k]).astype(float) for elm in l]) for k in keys] + + +# @jit +def get_init(res_x, res_y, x_persp, y_persp, camera_persp, x_offset, y_offset): + camera_pos = jnp.array([-camera_persp, 0, 0]) # from above: set last to -2 + + focal_plane = jnp.zeros((res_x, res_y, 3)) + x_grid, y_grid = jnp.meshgrid( + jnp.linspace(-x_persp, x_persp, res_x), jnp.linspace(-y_persp, y_persp, res_y) + ) + focal_plane = focal_plane.at[:, :, 1].set(x_grid.T + x_offset) + focal_plane = focal_plane.at[:, :, 2].set(y_grid.T + y_offset) + ray_dirs = focal_plane - camera_pos + ray_dirs = ray_dirs / jnp.linalg.norm(ray_dirs, axis=-1, keepdims=True) + + ray_origin = jnp.empty((res_x, res_y, 3)) + ray_origin = ray_origin.at[:, :].set(camera_pos) + + return ray_origin, ray_dirs diff --git a/rt.ipynb b/rt.ipynb deleted file mode 100644 index 63b25cd..0000000 --- a/rt.ipynb +++ /dev/null @@ -1,329 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "pip install -q git+https://github.com/cpgoodri/jax_transformations3d.git" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "import jax\n", - "from jax import jit, vmap\n", - "from functools import partial\n", - "import jax.numpy as jnp\n", - "import matplotlib.pyplot as plt\n", - "import jax_transformations3d as jts\n", - "import colorsys\n", - "import numpy as np\n", - "import math\n", - "import time\n", - "from tqdm.auto import tqdm, trange\n", - "\n", - "from utils import *" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "@partial(vmap, in_axes=(None, None, 0, 0), out_axes=-1)\n", - "def ray_intersect(ray_origin, ray_dir, sphere_center, sphere_radius):\n", - " # ray_dir should be normalized\n", - " offset_ray_origin = ray_origin - sphere_center\n", - " a = jnp.dot(ray_dir, ray_dir)\n", - " b = 2 * jnp.dot(offset_ray_origin, ray_dir)\n", - " c = jnp.dot(offset_ray_origin, offset_ray_origin) - sphere_radius**2\n", - "\n", - " discriminant = b**2 - 4 * a * c\n", - " dist = (-b - jnp.sqrt(discriminant)) / (2 * a)\n", - "\n", - " # sphere was hit if (discriminant >= 0) & (dist >= 0)\n", - " # if discriminant < 0, then dist is nan already, if dist < 0, \n", - " # meaning hitpoint is against ray direction, set dist to nan\n", - " dist = jnp.where(dist < 0, jnp.nan, dist)\n", - "\n", - " return dist\n", - "\n", - "def ray_intersect_target_batch(ray_origin, ray_dir, sphere_center, sphere_radius):\n", - " dist = ray_intersect(ray_origin, ray_dir, sphere_center, sphere_radius)\n", - " closest_hit = jnp.nanargmin(dist)\n", - " dist = dist[closest_hit]\n", - "\n", - " return dist, closest_hit" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(DeviceArray(7.1123, dtype=float32, weak_type=True),\n", - " DeviceArray(2, dtype=int32, weak_type=True))" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "jax.lax.fori_loop(0, 6, lambda i, x: (x[0]+1, x[1]), (1.1123, 2))" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [], - "source": [ - "def ray_trace_single_hit(\n", - " ray_origin,\n", - " ray_dir,\n", - " key,\n", - " sphere_center,\n", - " sphere_radius,\n", - " mat_color,\n", - " em_color,\n", - " em_strength,\n", - " mat\n", - "):\n", - " pass\n", - " \n", - "\n", - "\n", - "@jit\n", - "@partial(vmap, in_axes=(1, 1, 1, None, None, None, None, None, None))\n", - "@partial(vmap, in_axes=(0, 0, 0, None, None, None, None, None, None))\n", - "def full_ray_trace(\n", - " ray_origin,\n", - " ray_dir,\n", - " key,\n", - " sphere_center,\n", - " sphere_radius,\n", - " mat_color,\n", - " em_color,\n", - " em_strength,\n", - " mat,\n", - "):\n", - " inc_light = jnp.zeros((3,))\n", - " ray_color = jnp.ones((3,))\n", - " \n", - " jax.lax.fori_loop(0, 6, body_fun, init_val)\n", - "\n", - " for i in range(8):\n", - " dist, closest_hit = ray_intersect_target_batch(\n", - " ray_origin, ray_dir, sphere_center, sphere_radius\n", - " )\n", - "\n", - " did_hit = ~jnp.isnan(dist) # or: closest_hit != -1\n", - "\n", - " # done = done | (did_hit & (em_strength[closest_hit] == 1) & (jnp.arange(10)[i] == 0))\n", - " # did_hit = did_hit & ~done\n", - "\n", - " hit_point = ray_origin + ray_dir * dist\n", - " normal = hit_point - sphere_center[closest_hit]\n", - " normal = normal / jnp.linalg.norm(normal)\n", - "\n", - " emitted_light = em_color[closest_hit] * em_strength[closest_hit]\n", - " light_strength = jnp.dot(normal, -ray_dir)\n", - " light_strength = jnp.where(jnp.isnan(light_strength), 0, light_strength)\n", - " inc_light += did_hit * (emitted_light * ray_color)\n", - " # *light_strength\n", - " ray_color = (\n", - " did_hit * ray_color * mat_color[closest_hit] + (~did_hit) * ray_color\n", - " )\n", - "\n", - " key, subkey = jax.random.split(key, 2)\n", - " random_dir = jax.random.normal(subkey, (3,))\n", - " random_dir = random_dir / jnp.linalg.norm(random_dir)\n", - " diffuse_reflect = random_dir * jnp.sign(jnp.dot(random_dir, normal))\n", - " diffuse_reflect = diffuse_reflect / jnp.linalg.norm(diffuse_reflect)\n", - "\n", - " specular_reflect = (\n", - " ray_dir - 2 * jnp.dot(ray_dir, normal) * normal\n", - " ) # maybe should be -raydir too?\n", - " specular_reflect = specular_reflect / jnp.linalg.norm(specular_reflect)\n", - "\n", - " alpha = mat[closest_hit]\n", - " reflect_dir = alpha * diffuse_reflect + (1 - alpha) * specular_reflect\n", - "\n", - " ray_origin = hit_point\n", - " ray_dir = reflect_dir\n", - "\n", - " return inc_light" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "31.093120574951172\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# bounce count, time\n", - "# 4, 31\n", - "# 8, 61.3\n", - "# 16, 121-122\n", - "\n", - "sphere_pos, sphere_radius, mat_color, em_color, em_strength, mat = stack_dict_list(spheres)\n", - "\n", - "key = jax.random.PRNGKey(0)\n", - "result_img = jnp.zeros((res_y, res_x, 3))\n", - "\n", - "# this should be before every ray trace, but for now keep it here\n", - "x_offset, y_offset = (jax.random.uniform(subkey, (2,)) - 0.5) * 0.005\n", - "ray_pos, ray_dirs = get_init(res_x, res_y, x_persp, y_persp, camera_persp, x_offset, y_offset)\n", - "#\n", - "\n", - "result_img.block_until_ready()\n", - "t0 = time.time()\n", - "\n", - "k = 10\n", - "for i in range(k):\n", - " key, subkey = jax.random.split(key, 2)\n", - " key_grid = jax.random.split(subkey, res_x * res_y).reshape((res_x, res_y, -1))\n", - "\n", - " \n", - " result_img += full_ray_trace(\n", - " ray_pos,\n", - " ray_dirs,\n", - " key_grid,\n", - " sphere_pos,\n", - " sphere_radius,\n", - " mat_color,\n", - " em_color,\n", - " em_strength,\n", - " mat,\n", - " )\n", - "\n", - "result_img.block_until_ready()\n", - "print((time.time()-t0)*1000)\n", - "\n", - "plt.imshow(result_img/jnp.quantile(result_img.flatten(), 0.95))\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "base_res = 256\n", - "x_persp, y_persp = 1.5 * 3, 1 * 3\n", - "res_x, res_y = int(base_res * x_persp), int(base_res * y_persp)\n", - "camera_persp = 12\n", - "\n", - "\n", - "\n", - "n = 5\n", - "spheres = [\n", - " {\n", - " \"pos\": [5, -5 + l * 10, 0],\n", - " \"radius\": 1,\n", - " \"mat_color\": colorsys.hls_to_rgb(l * (1 - 1 / n), 0.5, 1),\n", - " \"em_color\": colorsys.hls_to_rgb(l * (1 - 1 / n), 0.5, 1),\n", - " \"em_strength\": 0,\n", - " \"mat\": max(l, 0.01),\n", - " }\n", - " for l in jnp.linspace(0, 1, n)\n", - "] + [\n", - " # {'pos': [10000+15, 0, 0], 'radius': 10000, 'mat_color': [1, 1, 1], 'em_color': [1, 1, 1], 'em_strength': 0.01, 'mat': 0.5},\n", - " # ground\n", - " {\n", - " \"pos\": [5, 0, 40000],\n", - " \"radius\": 40000 - 1,\n", - " \"mat_color\": [1, 1, 1],\n", - " \"em_color\": [1, 1, 1],\n", - " \"em_strength\": 0,\n", - " \"mat\": 1,\n", - " },\n", - " # back wall\n", - " # {'pos': [40000, 0, 0], 'radius': 40000-100, 'mat_color': [0.1, .1, 0.1], 'em_color': [1, 1, 1], 'em_strength': 0, 'mat': 1},\n", - " # ceiling light\n", - " {\n", - " \"pos\": [5, 0, -40000],\n", - " \"radius\": 40000 - 5000,\n", - " \"mat_color\": [1, 1, 1],\n", - " \"em_color\": [1, 1, 1],\n", - " \"em_strength\": 0.000001,\n", - " \"mat\": 1,\n", - " },\n", - " # {'pos': [10, 5, -5], 'radius': 4, 'mat_color': [1, 1, 1], 'em_color': [1, 1, 1], 'em_strength': 0, 'mat': 0},\n", - " # {'pos': [5-math.sin(math.pi*i*2)*10, math.cos(math.pi*i*2)*10, -4], 'radius': 1, 'mat_color': [0, 0, 0], 'em_color': [1, 1, 1], 'em_strength': 3, 'mat': 1},\n", - " # {'pos': [6, -10, 0], 'radius': 0.5, 'mat_color': [0, 0, 0], 'em_color': [0, 0.5, 1], 'em_strength': 40, 'mat': 1},\n", - "]" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "jax-tf", - "language": "python", - "name": "jax-tf" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/samples/output_1.png b/samples/output_1.png new file mode 100644 index 0000000..01ce698 Binary files /dev/null and b/samples/output_1.png differ diff --git a/samples/output_2.png b/samples/output_2.png new file mode 100644 index 0000000..842ef35 Binary files /dev/null and b/samples/output_2.png differ diff --git a/output.png b/samples/output_3.png similarity index 100% rename from output.png rename to samples/output_3.png diff --git a/output1.png b/samples/output_4.png similarity index 100% rename from output1.png rename to samples/output_4.png diff --git a/output2.png b/samples/output_5.png similarity index 100% rename from output2.png rename to samples/output_5.png diff --git a/samples/output_6.png b/samples/output_6.png new file mode 100644 index 0000000..346b170 Binary files /dev/null and b/samples/output_6.png differ diff --git a/samples/output_7.png b/samples/output_7.png new file mode 100644 index 0000000..0ca5673 Binary files /dev/null and b/samples/output_7.png differ diff --git a/samples/video.mp4 b/samples/video.mp4 new file mode 100644 index 0000000..cb74f44 Binary files /dev/null and b/samples/video.mp4 differ diff --git a/utils.py b/utils.py deleted file mode 100644 index fab5d43..0000000 --- a/utils.py +++ /dev/null @@ -1,31 +0,0 @@ -import jax.numpy as jnp -from jax import jit, vmap - -# coordinates are (x, y, z) -# x is forward backward -# y is left right -# z is up down - - -def stack_dict_list(l): - keys = l[0].keys() - return [jnp.stack([jnp.array(elm[k]).astype(float) for elm in l]) for k in keys] - -#@jit -def get_init(res_x, res_y, x_persp, y_persp, camera_persp, x_offset, y_offset): - camera_pos = jnp.array([-camera_persp, 0, 0]) # from above: set last to -2 - - focal_plane = jnp.zeros((res_x, res_y, 3)) - x_grid, y_grid = jnp.meshgrid( - jnp.linspace(-x_persp, x_persp, res_x), - jnp.linspace(-y_persp, y_persp, res_y) - ) - focal_plane = focal_plane.at[:, :, 1].set(x_grid.T + x_offset) - focal_plane = focal_plane.at[:, :, 2].set(y_grid.T + y_offset) - ray_dirs = focal_plane - camera_pos - ray_dirs = ray_dirs / jnp.linalg.norm(ray_dirs, axis=-1, keepdims=True) - - ray_origin = jnp.empty((res_x, res_y, 3)) - ray_origin = ray_origin.at[:, :].set(camera_pos) - - return ray_origin, ray_dirs