def main():
n = 100
xyz = 3 * (np.random.random((n, 3)) - 0.5)
r = 0.4 * np.random.random(n) + 0.002
rt = TkOptiX()
rt.set_param(min_accumulation_step=4, max_accumulation_frames=500)
rt.setup_light("light1", pos=[4, 5, 5], color=[8, 7, 6], radius=1.5)
rt.setup_light("light2", pos=[4, 15, -5], color=[8, 7, 6], radius=1.5)
rt.set_ambient([0.1, 0.2, 0.3])
rt.set_background(1)
rt.set_data("plot", xyz, r=r, c=0.8)
# shadow catcher makes the object transparent except regions where a light casts shadows,
# this can be useful e.g. for making packshot style images
rt.setup_material("shadow", m_shadow_catcher)
rt.set_data("plane",
pos=[-50, -2, -50],
u=[100, 0, 0],
v=[0, 0, 100],
c=1,
geom="Parallelograms",
mat="shadow")
rt.start()
print("done")
def main():
# tetrahedron vertices and faces:
pt = 1 / np.sqrt(2)
points = [[1, 0, -pt], [-1, 0, -pt], [0, 1, pt], [0, -1, pt]]
faces = [[0, 1, 2], [0, 1, 3], [1, 2, 3], [0, 2, 3]]
# colors assigned to vertices
colors = [
[0.7, 0, 0],
[0, 0.7, 0],
[0, 0, 0.7],
[1, 1, 1],
]
rt = TkOptiX() # create and configure, show the window later
rt.set_param(min_accumulation_step=2, max_accumulation_frames=100)
rt.setup_camera("cam1",
cam_type="DoF",
eye=[1, -6, 4],
focal_scale=0.9,
fov=25)
rt.setup_light("light1", pos=[10, -9, -8], color=[14, 13, 12], radius=4)
rt.set_ambient([0.2, 0.3, 0.4])
# add mesh geometry to the scene
rt.set_mesh("m", points, faces, c=colors)
rt.start()
print("done")
def main():
optix = TkOptiX() # create and configure, show the window later
optix.set_param(max_accumulation_frames=100) # accumulate up to 100 frames
optix.set_background(0) # black background
optix.set_ambient(0.25) # some ambient light
# original Stanford Utah teapot (try also with default value of make_normals=False):
# note: this file has no named objects specified, and you have to use load_merged_mesh_obj
# method
#optix.load_merged_mesh_obj("https://graphics.stanford.edu/courses/cs148-10-summer/as3/code/as3/teapot.obj",
# "teapot", c=0.92, make_normals=True)
# another public-domain version with normals included:
optix.load_mesh_obj("data/utah-teapot.obj", c=0.92)
# camera and light position auto-fit the scene geometry
optix.setup_camera("cam1")
d = np.linalg.norm(optix.get_camera_target() - optix.get_camera_eye())
optix.setup_light("light1", color=10, radius=0.3 * d)
optix.start()
print("done")
def main():
# Make some data first:
n = 3600
s = 50
m = -0.97
# try various m: 0.4, 2.48, -1.383, -2.03, ...
m = math.exp(m)
k = 1
xyz = [np.array([0, s * (math.e - 2), 0])]
t = 0
while t < n:
rad = math.pi * t / 180
f = s * (math.exp(math.cos(rad)) - 2 * math.cos(4 * rad) - math.pow(math.sin(rad/m), 5))
xyz.append(np.array([f * math.sin(rad), f * math.cos(rad), f * math.sin(2*rad)]))
t += k
r = np.linalg.norm(xyz, axis=1)
r = 5 - (5 / r.max()) * r + 0.02
# Create the plots:
optix = TkOptiX() # create and configure, show the window later
optix.set_background(0.99) # white background
optix.set_ambient(0.2) # dim ambient light
# add plot, BezierChain geometry makes a smooth line interpolating data points
optix.set_data("curve", pos=xyz, r=r, c=0.9, geom="BezierChain")
# show the UI window here - this method is calling some default
# initialization for us, e.g. creates camera, so any modification
# of these defaults should come below (or we provide on_initialization
# callback)
optix.show()
# camera auto-configured to fit the plot
optix.camera_fit()
# 2 spherical light sources, warm and cool, fit positions with respect to
# the current camera plane: 45 deg right/left and 25 deg up;
# do not include lights in geometry, so they do not appear in the image
optix.setup_light("light1", color=15*np.array([0.99, 0.9, 0.7]), radius=250, in_geometry=False)
optix.light_fit("light1", horizontal_rot=45, vertical_rot=25, dist_scale=1.1)
optix.setup_light("light2", color=20*np.array([0.7, 0.9, 0.99]), radius=200, in_geometry=False)
optix.light_fit("light2", horizontal_rot=-45, vertical_rot=25, dist_scale=1.1)
# accumulate up to 30 frames (override default of 4 frames)
optix.set_param(max_accumulation_frames=200)
print("done")
def main():
# Setup the raytracer:
rt = TkOptiX()
rt.set_param(min_accumulation_step=2, # update image every 2 frames
max_accumulation_frames=250) # accumulate 250 frames
exposure = 1.1; gamma = 2.2
rt.set_float("tonemap_exposure", exposure)
rt.set_float("tonemap_gamma", gamma)
rt.add_postproc("Denoiser") # Gamma correction, or use AI denoiser.
#rt.add_postproc("Gamma") # *** but not both together ***
rt.set_background(0)
rt.set_ambient(0)
# Prepare a simple scene objects, camera and lights:
rt.set_data("plane", geom="Parallelograms", pos=[[-15, 0, -15]], u=[30, 0, 0], v=[0, 0, 30], c=0.94)
rt.set_data("block1", geom="Parallelepipeds", pos=[[-6, -0.07, -1]], u=[12, 0, 0], v=[0, 0.1, 0], w=[0, 0, 3], c=0.94)
rt.set_data("block2", geom="Parallelepipeds", pos=[[-6, 0, -1]], u=[12, 0, 0], v=[0, 4, 0], w=[0, 0, 0.1], c=0.94)
# Setup lights and the camera:
rt.setup_light("light1", light_type="Parallelogram", pos=[-2.5, 2.6, 3], u=[0.8, 0, 0], v=[0, -0.8, 0], color=[4, 4.7, 5])
rt.setup_light("light2", light_type="Parallelogram", pos=[-0.5, 3.2, 0], u=[0.8, 0, 0], v=[0, 0, 0.8], color=[6, 5.6, 5.2])
rt.setup_light("light3", light_type="Parallelogram", pos=[1.5, 2.6, 3], u=[0.8, 0, 0], v=[0, -0.8, 0], color=[4, 4.7, 5])
rt.setup_camera("cam1", cam_type="DoF", eye=[0, 0.4, 6], target=[0, 1.2, 0], aperture_radius=0.025, fov=35, focal_scale=0.9)
# Make some data:
n = 20
x = np.linspace(-3, 3, n)
r = 0.8*np.cos(0.4*x)
y = np.sin(x + 5) + 1.3
z = np.cos(x + 5) + 0.3
data = np.stack((x, y, z)).T
# Add object to scene:
rt.set_data("balls", pos=data, r=r, c=0.93)
# or use another geometry and save it in the second scene file:
#rt.set_data("cubes", geom="Parallelepipeds", pos=data, r=r, c=0.92)
# Let's start:
rt.start()
# Save the scene. This actually can be called also before starting.
rt.save_scene("strange_object.json")
#rt.save_scene("strange_object_2.json") # the second file will be usefull in the scene loading example
print("done")
def main():
ru = rv = (-np.pi, 3*np.pi) # use with trefoil()
#ru = rv = (0, 2*np.pi) # use with torus()
#ru = (0, np.pi) # use with sphere()
#rv = (0, 2*np.pi)
n = 500
i = np.linspace(ru[0], ru[1], n)
j = np.linspace(rv[0], rv[1], n)
U, V = np.meshgrid(i, j)
S = trefoil(U, V, 5)
#S = sphere(U, V, 7)
#S = torus(U, V, 3, 5)
S = np.swapaxes(S, 0, 2)
rt = TkOptiX(width=750, height=900)
rt.set_param(min_accumulation_step=2, max_accumulation_frames=500, light_shading="Hard")
rt.set_uint("path_seg_range", 6, 15)
rt.setup_material("plastic", m_plastic)
exposure = 0.8; gamma = 2.2
rt.set_float("tonemap_exposure", exposure)
rt.set_float("tonemap_gamma", gamma)
rt.add_postproc("Gamma")
rt.set_background(0)
rt.set_ambient(0.15)
rt.set_surface("surface", S, c=0.94,
#wrap_u=True, wrap_v=True, # use wrapping to close a gap that can appear on u or v edges
make_normals=True, mat="plastic")
rt.set_data("plane", geom="Parallelograms",
pos=[[-100, -14, -100]], u=[200, 0, 0], v=[0, 0, 200],
c=make_color([0.1, 0.2, 0.3], exposure=exposure, gamma=gamma)[0])
rt.setup_camera("cam1", cam_type="DoF",
eye=[-50, -7, -15], target=[0, 0, -1], up=[0, 1, 0],
aperture_radius=0.4, aperture_fract=0.2,
focal_scale=0.92, fov=35)
rt.setup_light("light1", pos=[-15, 20, 15], color=5, radius=6)
rt.start()
print("done")
def main():
# make some data first:
rx = (-15, 5)
rz = (-10, 10)
n = 50
x = np.linspace(rx[0], rx[1], n)
z = np.linspace(rz[0], rz[1], n)
X, Z = np.meshgrid(x, z)
Y = f(X, Z)
rt = TkOptiX() # create and configure, show the window later
rt.set_param(max_accumulation_frames=50) # accumulate up to 50 frames
rt.set_background(0) # black background
rt.set_ambient(0.25) # some ambient light
# try commenting out optional arguments
rt.set_data_2d("surface",
Y,
range_x=rx,
range_z=rz,
c=map_to_colors(Y, "OrRd"),
floor_c=[0.05, 0.12, 0.38],
floor_y=-1.75,
make_normals=True)
# add wireframe above the surface
rt.set_data_2d("wireframe",
Y + 3,
range_x=rx,
range_z=rz,
r=0.06 * np.abs(Y),
geom="Graph",
c=0.92)
# set camera and light position to fit the scene
rt.setup_camera("cam1")
eye = rt.get_camera_eye()
eye[1] = 0.5 * eye[2]
rt.update_camera("cam1", eye=eye)
d = np.linalg.norm(rt.get_camera_target() - eye)
rt.setup_light("light1", color=8, radius=0.3 * d)
rt.start()
print("done")
def main():
# a mesh from pygmsh example:
with pygmsh.geo.Geometry() as geom:
poly = geom.add_polygon(
[
[+0.0, +0.5],
[-0.1, +0.1],
[-0.5, +0.0],
[-0.1, -0.1],
[+0.0, -0.5],
[+0.1, -0.1],
[+0.5, +0.0],
[+0.1, +0.1],
],
mesh_size=0.05,
)
geom.twist(
poly,
translation_axis=[0, 0, 1],
rotation_axis=[0, 0, 1],
point_on_axis=[0, 0, 0],
angle=np.pi / 3,
)
mesh = geom.generate_mesh()
rt = TkOptiX() # create and configure, show the window later
rt.set_param(min_accumulation_step=2, max_accumulation_frames=100)
rt.setup_camera("cam1",
cam_type="DoF",
eye=[0.5, -3, 2],
target=[0, 0, 0.5],
focal_scale=0.9,
fov=25)
rt.setup_light("light1", pos=[15, 0, 10], color=[8, 7, 6], radius=4)
rt.set_ambient([0.1, 0.15, 0.2])
# add mesh geometry to the scene
rt.set_mesh("m", mesh.points, mesh.cells_dict['triangle'])
rt.start()
print("done")
def main():
rt = TkOptiX(on_scene_compute=compute_changes,
on_rt_completed=update_scene)
# 4 accumulation passes on each compute-update cycle:
rt.set_param(min_accumulation_step=4)
n = 1000000
xyz = 3 * (np.random.random((n, 3)) - 0.5)
r = 0.02 * np.random.random(n) + 0.002
rt.set_data("plot", xyz, r=r)
rt.set_ambient(0.9)
rt.setup_camera("cam", eye=params.eye)
rt.start()
def main():
# a mesh from pygmsh example:
geom = pygmsh.built_in.Geometry()
# Draw a cross.
poly = geom.add_polygon(
[[0.0, 0.5, 0.0], [-0.1, 0.1, 0.0], [-0.5, 0.0, 0.0
], [-0.1, -0.1, 0.0],
[0.0, -0.5, 0.0], [0.1, -0.1, 0.0], [0.5, 0.0, 0.0], [0.1, 0.1, 0.0]],
lcar=0.05)
axis = [0, 0, 1]
geom.extrude(poly,
translation_axis=axis,
rotation_axis=axis,
point_on_axis=[0, 0, 0],
angle=2.0 / 6.0 * np.pi)
mesh = pygmsh.generate_mesh(geom)
rt = TkOptiX() # create and configure, show the window later
rt.set_param(min_accumulation_step=2, max_accumulation_frames=100)
rt.setup_camera("cam1",
cam_type="DoF",
eye=[0.5, -3, 2],
target=[0, 0, 0.5],
focal_scale=0.9,
fov=25)
rt.setup_light("light1", pos=[15, 0, 10], color=[8, 7, 6], radius=4)
rt.set_ambient([0.1, 0.15, 0.2])
# add mesh geometry to the scene
rt.set_mesh("m", mesh.points, mesh.cells_dict['triangle'])
rt.start()
print("done")
def main():
rt = TkOptiX() # create and configure, show the window later
rt.set_param(max_accumulation_frames=500) # accumulate up to 100 frames
rt.set_uint("path_seg_range", 6, 12) # allow some more ray segments
rt.set_background(0) # black background
rt.set_ambient([0.1, 0.12, 0.15]) # some ambient light
#rt.set_param(light_shading="Hard") # nice, accurate caustics, but slower convergence
exposure = 1; gamma = 2.2
rt.set_float("tonemap_exposure", exposure)
rt.set_float("tonemap_gamma", gamma)
rt.add_postproc("Gamma") # gamma correction
# setup materials:
m_diffuse["VarFloat3"] = { "base_color": [ 0.85, 0.87, 0.89 ] }
rt.update_material("diffuse", m_diffuse)
m_dispersive_glass["VarFloat3"]["base_color"] = [ 100, 110, 120 ]
rt.setup_material("glass", m_dispersive_glass)
# read the scene:
scene = trimesh.load("data/chemistry.glb")
# upload meshes to the ray tracer
for name in scene.geometry:
mesh = scene.geometry[name]
if name in ["bottle", "cap", "testtube"]:
rt.set_mesh(name, mesh.vertices, mesh.faces, mat="glass", make_normals=True)
else:
rt.set_mesh(name, mesh.vertices, mesh.faces)
# camera and light
rt.setup_light("light1", pos=[6,7.5,-15], color=30, radius=2)
rt.setup_camera("cam1", eye=[-2,5,-10], target=[-0.75,1.4,5], fov=23, glock=True)
rt.start()
print("done")
def main():
rt = TkOptiX() # create and configure, show the window later
rt.set_param(max_accumulation_frames=100) # accumulate up to 100 frames
rt.set_background(0.99) # white background
rt.set_ambient(0.25) # some ambient light
# setup materials:
m_diffuse["VarFloat3"] = {"base_color": [0.15, 0.17, 0.2]}
rt.update_material("diffuse", m_diffuse)
m_matt_plastic["VarFloat3"]["base_color"] = [0.5, 0.1, 0.05]
rt.setup_material("plastic", m_matt_plastic)
rt.load_texture("wing", "data/wing.png")
m_transparent_plastic["ColorTextures"] = ["wing"]
rt.setup_material("transparent", m_transparent_plastic)
rt.load_normal_tilt("transparent", "data/wing.png", prescale=0.002)
# prepare dictionary and load meshes; note that both eyes and wings
# are assigned with single material by providing only a part of
# the mesh name:
materials = {"eye": "plastic", "wing": "transparent"}
rt.load_multiple_mesh_obj("data/fly.obj",
materials,
parent="head_Icosphere")
# camera and light position auto-fit the scene geometry
rt.setup_camera("cam1")
d = np.linalg.norm(rt.get_camera_target() - rt.get_camera_eye())
rt.setup_light("light1", color=10, radius=0.3 * d)
rt.start()
print("done")
def main():
# Setup the raytracer:
rt = TkOptiX()
rt.set_param(min_accumulation_step=2, # update image every 2 frames
max_accumulation_frames=250) # accumulate 250 frames
rt.set_uint("path_seg_range", 5, 15) # allow many reflections/refractions
exposure = 1.5; gamma = 2.2
rt.set_float("tonemap_exposure", exposure)
rt.set_float("tonemap_igamma", 1 / gamma)
rt.add_postproc("Gamma") # Gamma correction, or use AI denoiser.
#rt.setup_denoiser() # *** but not both together ***
rt.set_background(0)
rt.set_ambient(0)
# Setup materials:
m_thin2 = m_thin_walled.copy() # textured material based on the predefined thin-walled material
m_thin2["Textures"] = [
{
"Baseline": 0.7, # Prescale the texture to make it bright, as one would expect for a bubbles:
"Prescale": 0.3, # color = Baseline + Prescale * original_color
"Gamma": 2.2, # And compensate the gamma correction applied in 2D postprocessing.
"Source": "data/rainbow.jpg",
"Format": RtFormat.Float4.value
}
]
rt.setup_material("glass", m_clear_glass)
rt.setup_material("thin", m_thin_walled)
rt.setup_material("thin2", m_thin2)
# Prepare a simple scene objects, camera and lights:
rt.set_data("plane", geom="Parallelograms", pos=[[-15, 0, -15]], u=[30, 0, 0], v=[0, 0, 30], c=0.94)
rt.set_data("block1", geom="Parallelepipeds", pos=[[-6, -0.07, -1]], u=[12, 0, 0], v=[0, 0.1, 0], w=[0, 0, 3], c=0.94)
rt.set_data("block2", geom="Parallelepipeds", pos=[[-6, 0, -1]], u=[12, 0, 0], v=[0, 4, 0], w=[0, 0, 0.1], c=0.94)
# Setup lights and the camera:
rt.setup_light("light1", light_type="Parallelogram", pos=[-2.5, 2.5, 3], u=[0.8, 0, 0], v=[0, -0.8, 0], color=[6, 5.7, 5.4])
rt.setup_light("light2", light_type="Parallelogram", pos=[-0.5, 3.2, 0], u=[0.8, 0, 0], v=[0, 0, 0.8], color=[8, 7.6, 7.2])
rt.setup_light("light3", light_type="Parallelogram", pos=[1.5, 2.5, 3], u=[0.8, 0, 0], v=[0, -0.8, 0], color=[6, 5.7, 5.4])
rt.setup_camera("cam1", cam_type="DoF", eye=[0, 0.4, 6], target=[0, 1, 0], aperture_radius=0.025, fov=35, focal_scale=0.9)
# Make some bubbles:
n = 20
x = np.linspace(-3, 3, n)
r = 0.3*np.cos(0.4*x)
y = 0.8*np.sin(x) + 1.2
z = 0.8*np.cos(x) + 0.4
b1 = np.stack((x, y, z)).T
rt.set_data("bubbles1", mat="thin", pos=b1, r=r, c=0.5+0.5*map_to_colors(x, "rainbow"))
y = 0.8*np.sin(x + 3) + 1.2
z = 0.8*np.cos(x + 3) + 0.4
b2 = np.stack((x, y, z)).T
rt.set_data("bubbles2", geom="ParticleSetTextured", mat="thin2", pos=b2, r=r)
y = np.sin(x + 2) + 1.2
z = np.cos(x + 2) + 0.4
b3 = np.stack((x, y, z)).T
rt.set_data("beads", mat="glass", pos=b3, r=0.75*r, c=10)
y = np.sin(x + 5) + 1.3
z = np.cos(x + 5) + 0.3
b4 = np.stack((x, y, z)).T
rt.set_data("balls", pos=b4, r=0.75*r, c=0.92)
# Let's start:
rt.start()
print("done")
def main():
ru = rv = (0, 2*np.pi)
n = 50
i = np.linspace(ru[0], ru[1], 2*n)[:-1]
j = np.linspace(rv[0], rv[1], n)[:-1]
U, V = np.meshgrid(i, j)
S = torus(U, V, 3, 5)
S = np.swapaxes(S, 0, 2)
rt = TkOptiX()
rt.set_param(min_accumulation_step=2, max_accumulation_frames=500, light_shading="Hard")
rt.set_uint("path_seg_range", 6, 15)
rt.setup_material("plastic", m_plastic)
exposure = 0.8; gamma = 2.2
rt.set_float("tonemap_exposure", exposure)
rt.set_float("tonemap_gamma", gamma)
rt.add_postproc("Gamma")
rt.set_background(0)
rt.set_ambient(0.0)
rt.set_surface("surface", S, c=0.95,
wrap_u=True, wrap_v=True,
mat="plastic",
make_normals=True
)
# make data for a bigger torus using normals calculated automatically
# for the firts object; note that this surface has normals oriented
# inwards - that's not a problem unless you'd like to have a refractive
# glass-like material, then use the code below that will flip normals
# (or simply change the surface formula, but this would not illustrate
# how to access buffers)
#with PinnedBuffer(rt.geometry_data["surface"], "Vectors") as N:
# print(S.shape, N.shape) # note that internal buffers are flat arrays of mesh vertex properties
# S -= N.reshape(S.shape)
# flip normals and update data on gpu, note that both normal vectors
# and vertex order should be inverted for correct shading
with PinnedBuffer(rt.geometry_data["surface"], "Vectors") as N:
with PinnedBuffer(rt.geometry_data["surface"], "FaceIdx") as F:
N *= -1 # flip shading normals
F[:,[0,1]] = F[:,[1,0]] # invert vertex order in faces, so geometry normals are consistent with shading normals
rt.update_geom_buffers("surface", GeomBuffer.Vectors | GeomBuffer.FaceIdx, forced=True) # update data on device
S += 0.5 * N.reshape(S.shape) # make data for a bigger torus
rt.set_surface("wireframe", S, c=[0.4, 0.01, 0],
r=0.015, geom="Graph",
wrap_u=True, wrap_v=True,
)
rt.set_data("plane", geom="Parallelograms",
pos=[[-100, -14, -100]], u=[200, 0, 0], v=[0, 0, 200],
c=make_color([0.1, 0.2, 0.3], exposure=exposure, gamma=gamma)[0])
rt.setup_camera("cam1", cam_type="DoF",
eye=[-50, -7, -15], target=[0, 0, -1], up=[0, 1, 0],
aperture_radius=0.4, aperture_fract=0.2,
focal_scale=0.92, fov=25)
rt.setup_light("light1", pos=[-15, 20, 15], color=5, radius=6)
rt.start()
print("done")
def main():
b = 7000 # number of curves
n = 60 # number pf nodes per curve
dt = 0.08 # nodes distance
ofs = 50 * np.random.rand(3)
inp = 5 * np.random.rand(b, 3, 4) - 2.5
for c in range(b):
inp[c, 1:, :3] = inp[c, 0, :3]
inp[c, :, 0] *= 1.75 # more spread in X
inp[c, :, 3] = ofs # sync the 4'th dim of the noise
#print(inp)
pos = np.zeros((b, n, 3), dtype=np.float32)
r = np.zeros((b, n), dtype=np.float32)
rnd = simplex(inp)
#print(rnd)
for t in range(n):
rt = 2.0 * (t + 1) / (n + 2) - 1
rt = 1 - rt * rt
r[:, t] = 0.07 * rt * rt
for c in range(b):
mag = np.linalg.norm(rnd[c])
r[c, t] *= 0.2 + 0.8 * mag # modulate thickness
rnd[c] = (dt / mag) * rnd[c] # normalize and scale the step size
inp[c, :, :3] += rnd[c] # step in the field direction
pos[c, t] = inp[c, 0, :3]
rnd = simplex(inp, rnd) # calculate noise at the next pos
rt = TkOptiX(start_now=False)
rt.set_param(
min_accumulation_step=1,
max_accumulation_frames=200,
rt_timeout=100000 # accept lower fps
)
exposure = 1.2
gamma = 1.8
rt.set_float("tonemap_exposure", exposure)
rt.set_float("tonemap_gamma", gamma)
rt.set_float("denoiser_blend", 0.25)
rt.add_postproc("Denoiser")
rt.setup_material("plastic", m_plastic)
for c in range(b):
if np.random.uniform() < 0.05:
rt.set_data("c" + str(c),
pos=pos[c],
r=1.1 * r[c],
c=[0.4, 0, 0],
geom="BezierChain")
else:
rt.set_data("c" + str(c),
pos=pos[c],
r=r[c],
c=0.94,
geom="BezierChain",
mat="plastic")
rt.setup_camera("dof_cam",
eye=[0, 0, 12],
target=[0, 0, 0],
fov=57,
focal_scale=0.7,
cam_type="DoF")
rt.setup_light("l1",
pos=[8, -3, 13],
color=1.5 * np.array([0.99, 0.97, 0.93]),
radius=5)
rt.setup_light("l2",
pos=[-17, -7, 5],
u=[0, 0, -10],
v=[0, 14, 0],
color=1 * np.array([0.25, 0.28, 0.35]),
light_type="Parallelogram")
rt.set_ambient([0.05, 0.07, 0.09])
rt.set_background(0)
rt.show()
print("done")
def main():
# make some data first:
b = 4
n = 200
k = 9.1
l = 1.1
m = 7.1
r0 = 0.06
q = 11
x = np.sin(np.linspace(0, 2 * b * k * np.pi, b * n))
y = np.cos(np.linspace(0, 2 * b * l * np.pi, b * n))
z = np.sin(np.linspace(0, 2 * b * m * np.pi, b * n))
pos = np.stack((x, y, z)).T
r = r0 * 0.5 * (1 +
np.sin(np.linspace(0, 2 * b * q * np.pi, b * n))) + 0.002
# create and configure, show the window later
optix = TkOptiX()
optix.set_param(min_accumulation_step=2, max_accumulation_frames=64)
optix.setup_material("plastic", m_plastic)
optix.setup_camera("dof_cam",
cam_type="DoF",
eye=[-4, 3, 4],
target=[0, 0, 0],
up=[0.21, 0.86, -0.46],
focal_scale=0.75)
# some exposure and gamma adjutments
optix.set_float("tonemap_exposure", 0.9)
optix.set_float("tonemap_gamma", 1.4)
optix.add_postproc("Gamma")
################################################################################
# Try one of the background / lighting settings:
# ------------------------------------------------------------------------------
# 1. Ray tracer is initialized in `AmbientLight` mode. There is a constant
# background color and an omnidirectional light with the color independent
# from the background:
#optix.setup_light("l1", color=4*np.array([0.99, 0.95, 0.9]), radius=3)
#optix.set_background([0, 0.02, 0.1]) # ambient and background colors can be
#optix.set_ambient(0.4) # RGB array or a gray level
# ------------------------------------------------------------------------------
# 2. `Default` (although not set by default initialization) mode uses
# background color to paint the background and as the ambient light,
# so a brighter one is better looking here:
#optix.set_background_mode("Default")
#optix.setup_light("l1", color=np.array([0.99, 0.95, 0.9]), radius=3) # just a little light from the side
#optix.set_background(0.94)
# ------------------------------------------------------------------------------
# 3. Environment map. Background texture is projected on the sphere with
# infinite radius, and it is also the source of the ambient light.
# make a small RGB texture with a vertical gradient
a = np.linspace(0.94, 0, 10)
b = np.zeros((10, 2, 3))
for i in range(10):
b[i, 0] = np.full(3, a[i])
b[i, 1] = np.full(3, a[i])
# extend to RGBA (RGB is fine to use with `set_background()`, but is converted to
# RGBA internally anyway)
bg = np.zeros((10, 2, 4), dtype=np.float32)
bg[:, :, :-1] = b
optix.set_background_mode("TextureEnvironment")
optix.setup_light("l1", color=np.array([0.99, 0.95, 0.9]),
radius=3) # just a little light from the side
optix.set_background(bg)
# ------------------------------------------------------------------------------
# 4. Fixed background texture. Background is just a wallpaper, you need to setup
# ambient light and/or other lights.
# make a small RGB texture with a vertical gradient
#a = np.linspace(0.94, 0, 10)
#b = np.zeros((10, 2, 3))
#for i in range(10):
# b[i,0]=np.full(3, a[i])
# b[i,1]=np.full(3, a[i])
#optix.set_background_mode("TextureFixed")
#optix.setup_light("l1", color=4*np.array([0.99, 0.95, 0.9]), radius=3)
#optix.set_background(b)
#optix.set_ambient(0.4)
# ------------------------------------------------------------------------------
# Note: background mode, lights, colors and textures can be all updated also
# after the window is open, while the ray tracing running.
################################################################################
# create a plot of parametric curve calculated above, and open the window
optix.set_data("plot",
pos=pos,
r=r,
c=0.94,
geom="BezierChain",
mat="plastic")
#optix.set_data("plot", pos=pos, r=r, c=0.94, geom="BSplineQuad", mat="plastic")
#optix.set_data("plot", pos=pos, r=r, c=0.94, geom="BSplineCubic", mat="plastic")
#optix.set_data("plot", pos=pos, r=r, c=0.94, geom="SegmentChain", mat="plastic")
optix.start()
print(optix.get_background_mode())
print("done")
def main():
# Make some data first:
n = 50000
xyz = 3 * (np.random.random((n, 3)) - 0.5)
r = 0.1 * (1 - (xyz[:, 0] / 3 + 0.5)) + 0.02
s = np.sum(xyz, axis=1)
particles = xyz[s > 0.2]
rp = r[s > 0.2]
# Use xyz positions to calculate RGB color components:
cp = particles / 3 + 0.5
cubes = xyz[s < -0.2]
rc = r[s < -0.2]
# Map Y-coordinate to matplotlib's color map RdYlBu: map_to_colors()
# function is automatically scaling the data to fit <0; 1> range.
# Any other mapping is OK, just keep the result in shape
# (n-data-points, 3), where 3 stands for RGB color
# components.
cc = map_to_colors(cubes[:, 1], "RdYlBu")
# Create plots:
optix = TkOptiX() # create and configure, show the window later
# accumulate up to 30 frames (override default of 4 frames)
optix.set_param(max_accumulation_frames=30)
# white background
optix.set_background(0.99)
# add plots, ParticleSet geometry is default
optix.set_data("particles", pos=particles, r=rp, c=cp)
# and use geom parameter to specify cubes geometry;
# Parallelepipeds can be described precisely with U, V, W vectors,
# but here we only provide the r parameter - this results with
# randomly rotated cubes of U, V, W lenghts equal to r
optix.set_data("cubes", pos=cubes, r=rc, c=cc, geom="Parallelepipeds")
# tetrahedrons look good as well, and they are really fast on RTX devices:
#optix.set_data("tetras", pos=cubes, r=rc, c=cc, geom="Tetrahedrons")
# if you prefer cubes aligned with xyz:
#optix.set_data("cubes", pos=cubes, r=rc, c=cc, geom="Parallelepipeds", rnd=False)
# or if you'd like some edges fixed:
#v = np.zeros((rc.shape[0], 3)); v[:,1] = rc[:]
#optix.set_data("cubes", pos=cubes, u=[0.05,0,0], v=v, w=[0,0,0.05], c=cc, geom="Parallelepipeds")
# show coordinates box
optix.set_coordinates()
# show the UI window here - this method is calling some default
# initialization for us, e.g. creates camera, so any modification
# of these defaults should come below (or we provide on_initialization
# callback)
optix.show()
# camera and lighting configured by hand
optix.update_camera(eye=[5, 0, -8])
optix.setup_light("light1",
color=10 * np.array([0.99, 0.9, 0.7]),
radius=2)
print("done")
def main():
# make some data first:
rx = (-1, 1.8)
rz = (-1, 1.8)
n = 18
x = np.linspace(rx[0], rx[1], n)
z = np.linspace(rz[0], rz[1], n)
X, Z = np.meshgrid(x, z)
Y = np.sqrt(X**2 + Z**2)
# positions of blocks
data = np.stack((X.flatten(), np.zeros(n * n), Z.flatten())).T
# 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
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
# 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")
# 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)
# AI denoiser includes exposure and gamma corection, configured with the
# same variables as the Gamma postprocessing algorithm.
optix.set_float("tonemap_exposure", 0.5)
optix.set_float("tonemap_gamma", 2.2)
# Denoiser blend allows for different mixing with the raw image. Its value
# can be modified also during the ray tracing.
# Note: denoising is applied when > 4 accumulation frames are completed.
optix.set_float("denoiser_blend", 0.25)
optix.add_postproc("Denoiser")
# Postprocessing stages are applied after AI denoiser (even if configured
# in a different order).
optix.set_float("levels_low_range", 0.1, 0.05, -0.05)
optix.set_float("levels_high_range", 0.95, 0.85, 0.8)
optix.add_postproc("Levels")
optix.start()
print("done")
def main():
# make some data first:
rx = (-1, 1.8)
rz = (-1, 1.8)
n = 18
x = np.linspace(rx[0], rx[1], n)
z = np.linspace(rz[0], rz[1], n)
X, Z = np.meshgrid(x, z)
Y = np.sqrt(X**2 + Z**2)
# positions of blocks
data = np.stack((X.flatten(), np.zeros(n * n), Z.flatten())).T
# 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
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
# 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")
# 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)
# 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")
# 2. Gamma correction.
#optix.set_float("tonemap_exposure", 0.8)
#optix.set_float("tonemap_igamma", 1 / 1.0)
#optix.add_postproc("Gamma")
# 3. Tonal correction with a custom curve.
optix.set_float("tonemap_exposure", 0.8)
# correction curve set explicitly:
optix.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")
# 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")
# 5. Overlay with a mask.
#mx = (-1, 1)
#mz = (-1, 1)
#nm = 20
#x = np.linspace(mx[0], mx[1], nm)
#z = np.linspace(mz[0], mz[1], nm)
#Mx, Mz = np.meshgrid(x, z)
#M = np.abs(Mx) ** 3 + np.abs(Mz) ** 3
#M = 1 - (0.6 / np.max(M)) * M
#optix.set_texture_2d("frame_mask", M)
#optix.add_postproc("Mask")
optix.start()
print("done")
def main():
# Setup the raytracer:
rt = TkOptiX()
rt.set_param(min_accumulation_step=2, # update image every 2 frames
max_accumulation_frames=250) # accumulate 250 frames
rt.set_uint("path_seg_range", 5, 15) # allow many reflections/refractions
exposure = 1.5; gamma = 2.2
rt.set_float("tonemap_exposure", exposure)
rt.set_float("tonemap_gamma", gamma)
rt.add_postproc("Denoiser") # AI denoiser, or the gamma correction only.
#rt.add_postproc("Gamma") # *** but not both together ***
rt.set_background(0)
rt.set_ambient(0)
# Setup texture:
# in one go, with gamma and exposure parameters saved to the scene:
rt.load_texture("rainbow", "data/rainbow.jpg", prescale=0.3, baseline=0.7, gamma=2.2)
# or through ndarray, allowing for custom processing:
#rainbow = 0.7 + 0.3 * read_image("data/rainbow.jpg", normalized=True)
#rainbow = make_color_2d(rainbow, gamma=2.2, channel_order="RGBA")
#rt.set_texture_2d("rainbow", rainbow)
# Setup materials:
m_thin2 = copy.deepcopy(m_thin_walled) # textured material based on the predefined thin-walled material
m_thin2["ColorTextures"] = [ "rainbow" ] # reference texture by name
rt.setup_material("glass", m_clear_glass)
rt.setup_material("thin", m_thin_walled)
rt.setup_material("thin2", m_thin2)
# Prepare a simple scene objects, camera and lights:
rt.set_data("plane", geom="Parallelograms", pos=[[-15, 0, -15]], u=[30, 0, 0], v=[0, 0, 30], c=0.94)
rt.set_data("block1", geom="Parallelepipeds", pos=[[-6, -0.07, -1]], u=[12, 0, 0], v=[0, 0.1, 0], w=[0, 0, 3], c=0.94)
rt.set_data("block2", geom="Parallelepipeds", pos=[[-6, 0, -1]], u=[12, 0, 0], v=[0, 4, 0], w=[0, 0, 0.1], c=0.94)
# Setup lights and the camera:
rt.setup_light("light1", light_type="Parallelogram", pos=[-2.5, 2.5, 3], u=[0.8, 0, 0], v=[0, -0.8, 0], color=[6, 5.7, 5.4])
rt.setup_light("light2", light_type="Parallelogram", pos=[-0.5, 3.2, 0], u=[0.8, 0, 0], v=[0, 0, 0.8], color=[8, 7.6, 7.2])
rt.setup_light("light3", light_type="Parallelogram", pos=[1.5, 2.5, 3], u=[0.8, 0, 0], v=[0, -0.8, 0], color=[6, 5.7, 5.4])
rt.setup_camera("cam1", cam_type="DoF", eye=[0, 0.4, 6], target=[0, 1, 0], aperture_radius=0.025, fov=35, focal_scale=0.9)
# Make some bubbles:
n = 20
x = np.linspace(-3, 3, n)
r = 0.3*np.cos(0.4*x)
y = 0.8*np.sin(x) + 1.2
z = 0.8*np.cos(x) + 0.4
b1 = np.stack((x, y, z)).T
rt.set_data("bubbles1", mat="thin", pos=b1, r=r, c=0.5+0.5*map_to_colors(x, "rainbow"))
y = 0.8*np.sin(x + 3) + 1.2
z = 0.8*np.cos(x + 3) + 0.4
b2 = np.stack((x, y, z)).T
rt.set_data("bubbles2", geom="ParticleSetTextured", mat="thin2", pos=b2, r=r)
y = np.sin(x + 2) + 1.2
z = np.cos(x + 2) + 0.4
b3 = np.stack((x, y, z)).T
rt.set_data("beads", mat="glass", pos=b3, r=0.75*r, c=10)
y = np.sin(x + 5) + 1.3
z = np.cos(x + 5) + 0.3
b4 = np.stack((x, y, z)).T
rt.set_data("balls", pos=b4, r=0.75*r, c=0.92)
# Let's start:
rt.start()
print("done")
def main():
# Make some data first (arbitrary scles):
data = np.random.normal(2, 0.8, 1000)
h, x = np.histogram(data, bins=15, range=(0, 4))
s = np.cumsum(h) / np.sum(h)
e = 6 * np.sqrt(h) / np.sum(h)
h = 3 * h / np.sum(h)
bin_size = x[1] - x[0]
# Create the plot:
optix = TkOptiX() # create and configure, show the window later
# accumulate more frames (override default of step=1 and max=4 frames)
optix.set_param(min_accumulation_step=2, max_accumulation_frames=100)
# Add data:
# - pos argument is used for bar positions
# - u and w vectors are used to set base x and z sizes
# - v is used to set bar heights.
ps = np.zeros((h.shape[0], 3))
ps[:, 0] = x[:-1]
vs = np.zeros((h.shape[0], 3))
vs[:, 1] = s
optix.set_data("cumulative",
pos=ps,
u=[0.9 * bin_size, 0, 0],
v=vs,
w=[0, 0, 0.8 * bin_size],
c=[0.6, 0, 0],
geom="Parallelepipeds")
ph = np.zeros((h.shape[0], 3))
ph[:, 0] = x[:-1]
ph[:, 2] = bin_size
vh = np.zeros((h.shape[0], 3))
vh[:, 1] = h
optix.set_data("density",
pos=ph,
u=[0.9 * bin_size, 0, 0],
v=vh,
w=[0, 0, 0.8 * bin_size],
c=0.95,
geom="Parallelepipeds")
pe = np.zeros((e.shape[0], 3))
pe[:, 0] = x[:-1]
pe[:, 1] = h
pe[:, 2] = bin_size
ve = np.zeros((e.shape[0], 3))
ve[:, 1] = e
optix.set_data("error",
pos=pe,
u=[0.9 * bin_size, 0, 0],
v=ve,
w=[0, 0, 0.8 * bin_size],
c=map_to_colors(e, "Blues"),
geom="Parallelepipeds")
# Setup camera and light:
optix.setup_camera("cam",
eye=[x[0], 1.5 * np.amax((h, s + e)), x[-1] - x[0]],
target=[(x[0] + x[-1]) / 2, 0, 0])
optix.setup_light("l1", color=10)
# show the UI window
optix.show()
print("done")