Merge pull request #47 from rnd-team-dev/r0.16.1

R0.16.1

Author: robertsulej

CHANGELOG.rst

@@ -1,6 +1,23 @@
 Release history
 ===============
 
+`v0.16.1` - 2023-06-04
+----------------------
+
+**NOTE:** Binaries recompiled with OptiX 7.7, NVIDIA driver r530 or above is required.
+
+Added
+~~~~~
+
+- CuPy support for texture and geometry data updates
+- New curve geometries: Ribbon, Beziers
+
+Changed
+~~~~~~~
+
+- no dedicated PyTorch/CuPy/... methods, all types handled with single corresponding method
+
+
 `v0.16.0` - 2023-05-17
 ----------------------
 
@@ -582,6 +599,7 @@ Added
 - this changelog, markdown description content type tag for PyPI
 - use [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
 
+.. _`v0.16.1`: https://github.com/rnd-team-dev/plotoptix/releases/tag/v0.16.1
 .. _`v0.16.0`: https://github.com/rnd-team-dev/plotoptix/releases/tag/v0.16.0
 .. _`v0.15.1`: https://github.com/rnd-team-dev/plotoptix/releases/tag/v0.15.1
 .. _`v0.15.0`: https://github.com/rnd-team-dev/plotoptix/releases/tag/v0.15.0

README.rst

@@ -44,7 +44,7 @@ No need to write shaders, intersection algorithms, handle 3D scene technicalitie
 
 Check `examples on GitHub <https://github.com/rnd-team-dev/plotoptix/tree/master/examples>`__ for practical code samples and `documentation pages <https://plotoptix.rnd.team>`__ for a complete API reference.
 
-PlotOptiX is a set of CUDA shaders by `R&D Team <https://rnd.team>`_ wrapped in C#/C++ libraries with a Python API. PlotOptiX is based on `NVIDIA OptiX 7.6 <https://developer.nvidia.com/optix>`_ framework and makes use of RTX-capable GPU's.
+PlotOptiX is a set of CUDA shaders by `R&D Team <https://rnd.team>`_ wrapped in C#/C++ libraries with a Python API. PlotOptiX is based on `NVIDIA OptiX 7.7 <https://developer.nvidia.com/optix>`_ framework and makes use of RTX-capable GPU's.
 
 You can quickly display data in a simple plot:
 
@@ -68,7 +68,7 @@ Features
 - *callbacks*: at the scene initialization, start and end of each frame raytracing, end of progressive accumulation
 - 8/16/32bps(hdr) image output to `numpy <https://numpy.org>`__ array, or save to popular image file formats
 - zero-copy access to GPU buffers wrapped in ndarrays: 8/32bpc image, hit and object info, albedo, normals
-- direct access to `PyTorch <https://pytorch.org>`__ tensors data stored on GPU (and CPU as well) for texture and geometry updates
+- direct access to `CuPy <https://cupy.dev>`__ and `PyTorch <https://pytorch.org>`__ tensors data stored on GPU (and CPU as well) for texture and geometry updates
 - GPU acceleration using RT Cores and everything else what comes with `OptiX <https://developer.nvidia.com/optix>`__
 - hardware accelerated video output to MP4 file format using `NVENC 9.0 <https://developer.nvidia.com/nvidia-video-codec-sdk>`__
 - Tkinter based simple GUI window or a headless raytracer
@@ -78,7 +78,7 @@ System Requirements
 -------------------
 
 - a `CUDA-enabled GPU <https://developer.nvidia.com/cuda-gpus>`__ with compute capability 5.0 (Maxwell) to latest (Ada Lovelace);
-   - NVIDIA driver >= r520;
+   - NVIDIA driver >= r530;
 - **Python 3 64-bit**
 - Windows:
    - Framework .NET >= 4.8 (present in all modern Windows)

docs/npoptix_config.rst

@@ -18,6 +18,7 @@ Start, configure, get output
 .. automethod:: plotoptix.NpOptiX._run_event_loop
 .. automethod:: plotoptix.NpOptiX.run
 .. automethod:: plotoptix.NpOptiX.get_gpu_architecture
+.. automethod:: plotoptix.NpOptiX.enable_cupy
 .. automethod:: plotoptix.NpOptiX.enable_torch
 
 Scene configuration
@@ -127,9 +128,7 @@ GPU variables related to the raytracer general configuraton are documented below
 .. automethod:: plotoptix.NpOptiX.get_float
 .. automethod:: plotoptix.NpOptiX.get_float2
 .. automethod:: plotoptix.NpOptiX.get_float3
-.. automethod:: plotoptix.NpOptiX.set_torch_texture_1d
 .. automethod:: plotoptix.NpOptiX.set_texture_1d
-.. automethod:: plotoptix.NpOptiX.set_torch_texture_2d
 .. automethod:: plotoptix.NpOptiX.set_texture_2d
 .. automethod:: plotoptix.NpOptiX.load_texture
 

examples/1_basics/2_beziers.py

@@ -0,0 +1,88 @@
+"""
+With ``Beziers`` geometry you can setup all control points and segments
+can be placed independently in contrast to other curve geometries where
+all data points are connected or interpolated with a single curve.
+
+This example shows how to:
+   - create a large set of independent bezier segments
+   - assign individual colors and radii to each segment
+"""
+
+import math
+import numpy as np
+from plotoptix import TkOptiX
+
+def random3d(n):
+    phi = np.random.uniform(0, 2 * np.pi, size=n)
+    costheta = np.random.uniform(-1, 1, size=n)
+
+    theta = np.arccos(costheta)
+    x = np.sin(theta) * np.cos(phi)
+    y = np.sin(theta) * np.sin(phi)
+    z = np.cos(theta)
+
+    return np.stack([x, y, z], axis=1)
+
+def main():
+
+    # create some data
+
+    n = 150000
+
+    # origins at (0,0,0)
+    xyz = np.zeros((n, 4, 3))
+
+    # control points #1 randomly distributed on the sphere
+    xyz[:,1,:] = random3d(n)
+
+    # endpoints follow the above direction, with some randomization
+    xyz[:,3,:] = 2 * xyz[:,1,:] + np.array([0, -0.75, 0])
+    xyz[:,3,:] += 0.75 * (np.random.rand(n, 3) - 0.5)
+
+    # control points #2 placed ~over the endpoints, so the curves look like falling down 
+    xyz[:,2,:] = xyz[:,3,:] + np.array([0, 0.5, 0])
+    xyz[:,2,:] += 0.2 * (np.random.rand(n, 3) - 0.5)
+
+    # reshape to have a single sequence of origin-ctrl#1-ctrl#2-endpoint for all segments
+    xyz = xyz.reshape((4 * n, 3))
+
+    c = np.array([
+        [0.4, 0.1, 0.1],
+        [0.7, 0.1, 0.1],
+        [0.9, 0.7, 0.9],
+        [0.93, 0.93, 0.93],
+    ])
+    c = np.tile(c, (n, 1))
+    c += 0.3 * (np.random.rand(4 * n, 3) - 0.5)
+    c = np.clip(c, 0, 1)
+
+    r = np.array([0.003, 0.008, 0.002, 0.0002])
+    r = np.tile(r, n)
+    print(xyz.shape, c.shape, r.shape)
+
+    # setup ray tracing
+
+    rt = TkOptiX()
+
+    rt.set_uint("path_seg_range", 8, 24)    # more segments to let the light enter between strands
+    rt.set_background(0.99)                 # white background
+    rt.set_ambient(0.15)                    # dim ambient light
+
+    rt.set_data("curve", pos=xyz, r=r, c=c, geom="Beziers")
+
+    rt.setup_camera("cam1", # cam_type="DoF",
+                    eye=[-6, 4, 5], target=[0, -0.6, 0],
+                    glock=True
+    )
+
+    rt.setup_light("light1", pos=[-6, 10, 10], color=10*np.array([0.99, 0.9, 0.7]), radius=3, in_geometry=True)
+    rt.setup_light("light2", pos=[-6, -10, 5], color=20*np.array([0.7, 0.9, 0.99]), radius=2, in_geometry=True)
+
+    rt.set_param(max_accumulation_frames=256)
+
+    rt.show()
+
+    print("done")
+
+if __name__ == '__main__':
+    main()

examples/1_basics/2_parametric_line_plot_3d.py

@@ -46,15 +46,16 @@ def main():
     rt.set_ambient(0.2)     # dim ambient light
 
     # add plot: BezierChain geometry makes a smooth line interpolating data points
-    #rt.set_data("curve", pos=xyz, r=r, c=0.9, geom="BezierChain")
+    rt.set_data("curve", pos=xyz, r=r, c=0.9, geom="BezierChain")
 
     # or use SegmentChain for a piecewise-linear plot
     #rt.set_data("curve", pos=xyz, r=r, c=0.9, geom="SegmentChain")
 
     # or use b-spline geometry (approximating data points, flat end caps)
     #rt.set_data("curve", pos=xyz, r=r, c=0.9, geom="BSplineQuad")
     #rt.set_data("curve", pos=xyz, r=r, c=0.9, geom="BSplineCubic")
-    rt.set_data("curve", pos=xyz, r=r, c=0.9, geom="CatmullRom")
+    #rt.set_data("curve", pos=xyz, r=r, c=0.9, geom="CatmullRom")
+    #rt.set_data("curve", pos=xyz, r=r, c=0.9, geom="Ribbon")
 
     # show the UI window here - this method is calling some default
     # initialization for us, e.g. creates camera, so any modification

examples/1_basics/6_postprocessing.py

@@ -24,56 +24,58 @@ def main():
     # heights of blocks
     v = np.zeros(data.shape); v[:,1] = (Y.flatten() + 0.3 * np.random.rand(n*n))[:]
 
-    optix = TkOptiX() # create and configure, show the window later
+    rt = TkOptiX() # create and configure, show the window later
 
-    optix.set_param(max_accumulation_frames=50)  # accumulate up to 50 frames
-    optix.set_background(0)          # black background
-    optix.set_ambient([0, 0.2, 0.4]) # cold ambient light
+    rt.set_param(max_accumulation_frames=50)  # accumulate up to 50 frames
+    rt.set_background(0)          # black background
+    rt.set_ambient([0, 0.2, 0.4]) # cold ambient light
 
     # add plot geometry
     size_u = 0.98 * (rx[1] - rx[0]) / (n - 1)
     size_w = 0.98 * (rz[1] - rz[0]) / (n - 1)
-    optix.set_data("blocks", pos=data,
-                   u=[size_u, 0, 0], v=v, w=[0, 0, size_w],
-                   c = np.random.rand(n*n),
-                   geom="Parallelepipeds")
+    rt.set_data("blocks", pos=data,
+                u=[size_u, 0, 0], v=v, w=[0, 0, size_w],
+                c = np.random.rand(n*n),
+                geom="Parallelepipeds"
+    )
 
     # set camera and light position
-    optix.setup_camera("cam1", cam_type="DoF",
-                       eye=[-0.3, 2, -0.3], target=[1, 1, 1],
-                       fov=60, focal_scale=0.85)
-    optix.setup_light("light1", pos=[3, 4.5, 1], color=[6, 5, 4.5], radius=2)
+    rt.setup_camera("cam1", cam_type="DoF",
+                    eye=[-0.3, 2, -0.3], target=[1, 1, 1],
+                    fov=60, focal_scale=0.85
+    )
+    rt.setup_light("light1", pos=[3, 4.5, 1], color=[6, 5, 4.5], radius=2)
 
 
     # Postprocessing configuration - uncomment what you'd like to include
     # or comment out all stages to see raw image. Try also combining
     # the mask overlay with one of tonal or levels corrections.
 
     # 1. Levels adjustment.
-    #optix.set_float("levels_low_range", 0.1, 0.05, -0.05)
-    #optix.set_float("levels_high_range", 0.9, 0.85, 0.8)
-    #optix.add_postproc("Levels")
+    #rt.set_float("levels_low_range", 0.1, 0.05, -0.05)
+    #rt.set_float("levels_high_range", 0.9, 0.85, 0.8)
+    #rt.add_postproc("Levels")
 
     # 2. Gamma correction.
-    #optix.set_float("tonemap_exposure", 0.8)
-    #optix.set_float("tonemap_gamma", 2.2)
-    #optix.add_postproc("Gamma")
+    #rt.set_float("tonemap_exposure", 0.8)
+    #rt.set_float("tonemap_gamma", 2.2)
+    #rt.add_postproc("Gamma")
 
     # 3. Tonal correction with a custom curve.
-    optix.set_float("tonemap_exposure", 0.8)
+    rt.set_float("tonemap_exposure", 0.8)
     # correction curve set explicitly:
-    optix.set_texture_1d("tone_curve_gray", np.sqrt(np.linspace(0, 1, 64)))
+    rt.set_texture_1d("tone_curve_gray", np.sqrt(np.linspace(0, 1, 64)))
     # correction curve calculated from control input/output values
-    # (convenient if the curve was prepared in an image editor)
-    #optix.set_correction_curve([[13,51], [54, 127], [170, 192]])
-    optix.add_postproc("GrayCurve")
+    # (convenient if the curve was prepared eg in an image editor)
+    #rt.set_correction_curve([[13,51], [54, 127], [170, 192]])
+    rt.add_postproc("GrayCurve")
 
     # 4. Tonal correction with a custom RGB curves.
-    #optix.set_float("tonemap_exposure", 0.8)
-    #optix.set_texture_1d("tone_curve_r", np.sqrt(np.linspace(0.1, 1, 64)))
-    #optix.set_texture_1d("tone_curve_g", np.sqrt(np.linspace(0, 1, 64)))
-    #optix.set_texture_1d("tone_curve_b", np.sqrt(np.linspace(0, 1, 64)))
-    #optix.add_postproc("RgbCurve")
+    #rt.set_float("tonemap_exposure", 0.8)
+    #rt.set_texture_1d("tone_curve_r", np.sqrt(np.linspace(0.15, 1, 64)))
+    #rt.set_texture_1d("tone_curve_g", np.sqrt(np.linspace(0, 1, 64)))
+    #rt.set_texture_1d("tone_curve_b", np.sqrt(np.linspace(0, 1, 64)))
+    #rt.add_postproc("RgbCurve")
 
     # 5. Overlay with a mask.
     #mx = (-1, 1)
@@ -89,11 +91,11 @@ def main():
 
     #M = make_color_2d(M, channel_order="RGBA")
 
-    #optix.set_texture_2d("frame_mask", M)
-    #optix.add_postproc("Mask")
+    #rt.set_texture_2d("frame_mask", M)
+    #rt.add_postproc("Mask")
 
 
-    optix.start()
+    rt.start()
     print("done")