def build_and_render(scene, accel_name):
accel = lm.load_accel('accel', accel_name)
scene.set_accel(accel.loc())
scene.build()
film = lm.load_film('film_output', 'bitmap', w=1920, h=1080)
renderer = lm.load_renderer('renderer',
'raycast',
scene=scene,
output=film)
renderer.render()
return np.copy(film.buffer())
def build_and_render(scene, accel_name):
accel = lm.load_accel('accel', accel_name, {})
scene.set_accel(accel.loc())
scene.build()
film = lm.load_film('film_output', 'bitmap', {'w': 1920, 'h': 1080})
renderer = lm.load_renderer('renderer', 'raycast', {
'scene': scene.loc(),
'output': film.loc()
})
renderer.render()
return np.copy(film.buffer())
def build_and_render(scene_name):
lm.reset()
accel = lm.load_accel('accel', 'embree', {})
scene = lm.load_scene('scene', 'default', {'accel': accel.loc()})
lmscene.load(scene, env.scene_path, scene_name)
scene.build()
film = lm.load_film('film_output', 'bitmap', {'w': 1920, 'h': 1080})
renderer = lm.load_renderer('renderer', 'raycast', {
'scene': scene.loc(),
'output': film.loc()
})
renderer.render()
return np.copy(film.buffer())
def build_and_render(scene_name):
lm.reset()
accel = lm.load_accel('accel', 'embree')
scene = lm.load_scene('scene', 'default', accel=accel)
lmscene.load(scene, env.scene_path, scene_name)
scene.build()
film = lm.load_film('film_output', 'bitmap', w=1920, h=1080)
renderer = lm.load_renderer('renderer',
'raycast',
scene=scene,
output=film)
renderer.render()
return np.copy(film.buffer())
def render(scene, name, **kwargs):
w = 854
h = 480
film = lm.load_film('film', 'bitmap', w=w, h=h)
renderer = lm.load_renderer('renderer', name,
scene=scene,
output=film,
max_verts=10,
scheduler='time',
render_time=30,
**kwargs)
renderer.render()
return np.copy(film.buffer())
def render(renderer_asset_id, renderer_name, params):
"""Render an image."""
# Create a film for the output
film = lm.load_film('film_' + renderer_asset_id, 'bitmap', {
'w': params['w'],
'h': params['h']
})
# Execute rendering
renderer = lm.load_renderer(renderer_asset_id, renderer_name, {
**params,
'output': film.loc()
})
out = renderer.render()
return np.copy(film.buffer()), out
def render(scene, name, renderer_name, base_dir, num_verts, **kwargs):
w = 1920
h = 1080
film = lm.load_film('film', 'bitmap', w=w, h=h)
renderer = lm.load_renderer('renderer', renderer_name,
scene=scene,
output=film,
min_verts=num_verts, # Number of vertices must be the same
max_verts=num_verts,
scheduler='time',
render_time=30,
seed=42,
**kwargs)
out = renderer.render()
print(json.dumps(out, indent=2))
film.save(os.path.join(base_dir, name + '.hdr'))
return np.copy(film.buffer())
def render(scene, name, **kwargs):
w = 854
h = 480
# w = 1920
# h = 1080
film = lm.load_film('film', 'bitmap', w=w, h=h)
renderer = lm.load_renderer('renderer',
name,
scene=scene,
output=film,
min_verts=3,
max_verts=3,
scheduler='time',
render_time=20,
samples_per_iter=10,
**kwargs)
out = renderer.render()
print(json.dumps(out, indent=2))
film.save(os.path.join(temp_dir, name + '.hdr'))
return np.copy(film.buffer())
def render(scene, name, **kwargs):
if not lm.Release:
w = 64
h = 48
else:
w = 640
h = 480
film = lm.load_film('film', 'bitmap', w=w, h=h)
renderer = lm.load_renderer('renderer',
name,
scene=scene,
output=film,
min_verts=3,
max_verts=3,
scheduler='time',
render_time=60,
seed=20,
**kwargs)
out = renderer.render()
print(json.dumps(out, indent=2))
film.save(os.path.join(temp_dir, name + '.hdr'))
return np.copy(film.buffer())
})
accel = lm.load_accel('accel', 'sahbvh', {})
scene = lm.load_scene('scene', 'default', {
'accel': accel.loc()
})
scene.add_primitive({
'camera': camera.loc()
})
scene.add_primitive({
'model': model.loc()
})
scene.build()
film = lm.load_film('film_output', 'bitmap', {'w': 1920, 'h': 1080})
renderer = lm.load_renderer('renderer', 'raycast', {
'scene': scene.loc(),
'output': film.loc()
})
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(10,10))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img,1/2.2),0,1), origin='lower')
ax.set_title('orig')
# Replace `obj_base_mat` with different color
# Note that this is not trivial, because `model::wavefrontobj`
# already holds a reference to the original material.
lm.load_material('obj_base_mat', 'diffuse', {
'Kd': [.2,.8,.2]
})
'camera1', 'pinhole', {
'position': [5.101118, 1.083746, -2.756308],
'center': [4.167568, 1.078925, -2.397892],
'up': [0, 1, 0],
'vfov': 43.001194
})
# Scene
accel = lm.load_accel('accel', 'sahbvh', {})
scene = lm.load_scene('scene', 'default', {'accel': accel.loc()})
scene.add_primitive({'camera': camera.loc()})
scene.add_primitive({'model': model.loc()})
scene.build()
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# Executing the renderer will produce the following image.
# -
renderer = lm.load_renderer('renderer', 'raycast', {
'scene': scene.loc(),
'output': film.loc(),
'use_constant_color': True
})
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(15, 15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img, 1 / 2.2), 0, 1), origin='lower')
plt.show()
up=[0,1,0],
vfov=43.001194,
aspect=16/9)
material = lm.load_material('obj_base_mat', 'diffuse',
Kd=[.8,.2,.2])
model = lm.load_model('model_obj', 'wavefrontobj',
path=os.path.join(env.scene_path, 'fireplace_room/fireplace_room.obj'),
base_material=material)
accel = lm.load_accel('accel', 'sahbvh')
scene = lm.load_scene('scene', 'default', accel=accel)
scene.add_primitive(camera=camera)
scene.add_primitive(model=model)
scene.build()
film = lm.load_film('film_output', 'bitmap', w=1920, h=1080)
renderer = lm.load_renderer('renderer', 'raycast', scene=scene, output=film)
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(10,10))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img,1/2.2),0,1), origin='lower')
ax.set_title('orig')
# Replace `obj_base_mat` with different color
# Note that this is not trivial, because `model::wavefrontobj`
# already holds a reference to the original material.
lm.load_material('obj_base_mat', 'diffuse', Kd=[.2,.8,.2])
renderer.render()
lmscene.load(scene, env.scene_path, 'fireplace_room')
scene.build()
film = lm.load_film('film_output', 'bitmap', w=1920, h=1080)
shared_renderer_params = {
'scene': scene.loc(),
'output': film.loc(),
'image_sample_mode': 'image',
'max_verts': 20,
}
# ### w/ sample-based scheduler
renderer = lm.load_renderer('renderer',
'pt',
**shared_renderer_params,
scheduler='sample',
spp=1,
num_samples=10000000)
renderer.render()
img1 = np.copy(film.buffer())
f = plt.figure(figsize=(15, 15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img1, 1 / 2.2), 0, 1), origin='lower')
plt.show()
# ### w/ time-based scheduler
renderer = lm.load_renderer('renderer',
'pt',
**shared_renderer_params,
'wavefrontobj',
path=os.path.join(env.scene_path,
'fireplace_room/fireplace_room.obj'))
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# We can create primitives from the loaded mode using ``model` parameter for the :cpp:func:`lm::Scene::add_primitive` function.
# -
accel = lm.load_accel('accel', 'sahbvh')
scene = lm.load_scene('scene', 'default', accel=accel)
scene.add_primitive(camera=camera)
scene.add_primitive(model=model)
scene.build()
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# Executing the renderer will produce the following image.
# -
renderer = lm.load_renderer('renderer',
'raycast',
scene=scene,
output=film,
bg_color=[0, 0, 0])
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(15, 15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img, 1 / 2.2), 0, 1), origin='lower')
plt.show()
lmscene.load(scene, env.scene_path, 'fireplace_room')
scene.build()
film = lm.load_film('film_output', 'bitmap', {'w': 1920, 'h': 1080})
shared_renderer_params = {
'scene': scene.loc(),
'output': film.loc(),
'image_sample_mode': 'image',
'max_length': 20,
}
# ### w/ sample-based scheduler
renderer = lm.load_renderer(
'renderer', 'pt', {
**shared_renderer_params, 'scheduler': 'sample',
'spp': 1,
'num_samples': 10000000
})
renderer.render()
img1 = np.copy(film.buffer())
f = plt.figure(figsize=(15, 15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img1, 1 / 2.2), 0, 1), origin='lower')
plt.show()
# ### w/ time-based scheduler
renderer = lm.load_renderer('renderer', 'pt', {
**shared_renderer_params,
'scheduler': 'time',
})
# OBJ model
model = lm.load_model('model', 'wavefrontobj', {
'path':
os.path.join(env.scene_path, 'fireplace_room/fireplace_room.obj')
})
# -
accel = lm.load_accel('accel', 'sahbvh', {})
scene = lm.load_scene('scene', 'default', {'accel': accel.loc()})
scene.add_primitive({'camera': camera.loc()})
scene.add_primitive({'model': model.loc()})
scene.build()
renderer = lm.load_renderer(
'renderer', 'pt', {
'scene': scene.loc(),
'output': film.loc(),
'scheduler': 'sample',
'spp': 10,
'max_length': 20
})
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(15, 15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img, 1 / 2.2), 0, 1), origin='lower')
plt.show()
# Load scene and render
print('w/o serialization')
lm.reset()
lm.load_film('film_output', 'bitmap', {
'w': 1920,
'h': 1080
})
lm.load_accel('accel', 'sahbvh', {})
scene = lm.load_scene('scene', 'default', {
'accel': '$.assets.accel'
})
lmscene.load(scene, env.scene_path, scene_name)
scene.build()
lm.load_renderer('renderer', 'raycast', {
'scene': '$.assets.scene',
'output': '$.assets.film_output',
})
renderer = lm.get_renderer('$.assets.renderer')
renderer.render()
film = lm.get_film('$.assets.film_output')
img_orig = np.copy(film.buffer())
# Visualize
f = plt.figure(figsize=(15,15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img_orig,1/2.2),0,1), origin='lower')
plt.show()
# Serialize, reset, deserialize, and render
print('w/ serialization')
'up': [0, 1, 0],
'vfov': 43.001194
})
# OBJ model
model = lm.load_model('obj1', 'wavefrontobj', {
'path':
os.path.join(env.scene_path, 'fireplace_room/fireplace_room.obj')
})
# Scene
accel = lm.load_accel('accel', 'sahbvh', {})
scene = lm.load_scene('scene', 'default', {'accel': accel.loc()})
scene.add_primitive({'camera': camera.loc()})
scene.add_primitive({'model': model.loc()})
scene.build()
# -
renderer = lm.load_renderer('renderer', 'ao', {
'scene': scene.loc(),
'output': film.loc(),
'spp': 10
})
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(15, 15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img, 1 / 2.2), 0, 1), origin='lower')
plt.show()
'material': 'material1'
})
except Exception:
traceback.print_exc()
# This is correct
scene.add_primitive({
'mesh': '$.assets.mesh1',
'material': '$.assets.material1'
})
# ### Rendering with invalid scene
renderer = lm.load_renderer('renderer', 'raycast', {
'scene': scene.loc(),
'output': '$.assets.film1',
'color': [0,0,0]
})
try:
# Without camera
renderer.render()
except Exception:
traceback.print_exc()
# Add camera primitive
scene.add_primitive({
'camera': '$.assets.camera1'
})
try:
# Also note that the serialized asset can be loaded in a different location in the asset tree, for instance, as a child of the different asset group.
g = lm.load_asset_group('another_group', 'default', {})
g.load_serialized('fireplace_room', 'fireplace_room.serialized')
lm.print_asset_tree()
# ### Rendering with serialized asset
#
# We can render the image using the serializaed asset. Here we are using a locator directly instead of ``.loc()`` function, since the previously obtained reference (``scene``) became invalid.
# Rendering
film = lm.load_film('film', 'bitmap', {
'w': 1920,
'h': 1080
})
renderer = lm.load_renderer('renderer', 'pt', {
'scene': '$.assets.another_group.fireplace_room.scene',
'output': film.loc(),
'scheduler': 'sample',
'spp': 1,
'max_length': 20
})
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(15,15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img,1/2.2),0,1), origin='lower')
plt.show()
up=[0,1,0],
vfov=43.001194,
aspect=16/9)
# OBJ model
model = lm.load_model('obj1', 'wavefrontobj',
path=os.path.join(env.scene_path, 'fireplace_room/fireplace_room.obj'))
# Scene
accel = lm.load_accel('accel', 'sahbvh')
scene = lm.load_scene('scene', 'default', accel=accel)
scene.add_primitive(camera=camera)
scene.add_primitive(model=model)
scene.build()
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# We can use the loaded extension in the same way as build-in assets using ``lm::load_*`` function. Here we load the renderer ``renderer::io`` and process rendering.
# -
renderer = lm.load_renderer('renderer', 'ao',
scene=scene,
output=film,
spp=5)
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(15,15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img,1/2.2),0,1), origin='lower')
plt.show()
# -
accel = lm.load_accel('accel', 'sahbvh', {})
scene = lm.load_scene('scene', 'default', {
'accel': accel.loc()
})
scene.add_primitive({
'camera': camera.loc()
})
scene.add_primitive({
'model': model.loc()
})
scene.build()
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# Executing the renderer will produce the following image.
# -
renderer = lm.load_renderer('renderer', 'raycast', {
'scene': scene.loc(),
'output': film.loc(),
'bg_color': [0,0,0]
})
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(15,15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img,1/2.2),0,1), origin='lower')
plt.show()
lm.load_material('material1', 'diffuse', Kd=[1, 1, 1])
try:
# 'material1' is not a valid locator
scene.add_primitive(mesh='$.assets.mesh1', material='material1')
except Exception:
traceback.print_exc()
# This is correct
scene.add_primitive(mesh='$.assets.mesh1', material='$.assets.material1')
# ### Rendering with invalid scene
renderer = lm.load_renderer('renderer',
'raycast',
scene=scene,
output='$.assets.film1',
color=[0, 0, 0])
try:
# Without camera
renderer.render()
except Exception:
traceback.print_exc()
# Add camera primitive
scene.add_primitive(camera='$.assets.camera1')
try:
# With camera, but without build()
renderer.render()
rmse_series = pd.Series(index=scene_names)
for scene_name in scene_names:
print("Testing [scene='{}']".format(scene_name))
# Load scene and render
print('w/o serialization')
lm.reset()
lm.load_film('film_output', 'bitmap', w=1920, h=1080)
lm.load_accel('accel', 'sahbvh')
scene = lm.load_scene('scene', 'default', accel='$.assets.accel')
lmscene.load(scene, env.scene_path, scene_name)
scene.build()
lm.load_renderer('renderer',
'raycast',
scene='$.assets.scene',
output='$.assets.film_output')
renderer = lm.get_renderer('$.assets.renderer')
renderer.render()
film = lm.get_film('$.assets.film_output')
img_orig = np.copy(film.buffer())
# Visualize
f = plt.figure(figsize=(15, 15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img_orig, 1 / 2.2), 0, 1), origin='lower')
plt.show()
# Serialize, reset, deserialize, and render
print('w/ serialization')
vfov=43.001194,
aspect=16 / 9)
# OBJ model
model = lm.load_model('model',
'wavefrontobj',
path=os.path.join(env.scene_path,
'fireplace_room/fireplace_room.obj'))
# -
accel = lm.load_accel('accel', 'sahbvh')
scene = lm.load_scene('scene', 'default', accel=accel)
scene.add_primitive(camera=camera)
scene.add_primitive(model=model)
scene.build()
renderer = lm.load_renderer('renderer',
'pt',
scene=scene,
output=film,
scheduler='sample',
spp=5,
max_verts=20)
renderer.render()
img = np.copy(film.buffer())
f = plt.figure(figsize=(15, 15))
ax = f.add_subplot(111)
ax.imshow(np.clip(np.power(img, 1 / 2.2), 0, 1), origin='lower')
plt.show()
'p': fs.flatten().tolist(),
't': fs.flatten().tolist(),
'n': fs.flatten().tolist()
})
camera = lm.load_camera('camera_main',
'pinhole',
position=[0, 0, 50],
center=[0, 0, 0],
up=[0, 1, 0],
vfov=30,
aspect=16 / 9)
material = lm.load_material('material_white', 'diffuse', Kd=[1, 1, 1])
film = lm.load_film('film_output', 'bitmap', w=1920, h=1080)
renderer = lm.load_renderer('renderer',
'raycast',
scene=scene,
output=film,
visualize_normal=True,
bg_color=[1, 1, 1])
# -
# ### Without instancing
# +
scene.reset()
scene.add_primitive(camera=camera)
for y in np.linspace(-10, 10, 10):
for x in np.linspace(-10, 10, 10):
p = scene.create_primitive_node(mesh=mesh, material=material)
t = scene.create_group_node(lm.translate(np.array([x, y, 0])))
scene.add_child(t, p)
# Lightmetrica uses `component locator` to access the instance.
#
# A component locator is a string starting with the character ``$`` and the words connected by ``.``. A locator indicates a location of the instance managed by the framework. For instance, the locator of the ``film`` asset is ``$.assets.film``. This can be queried by ``.loc()`` function.
# -
film.loc()
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# To rendering an image, we need to create `renderer` asset. Here, we will create ``renderer::blank`` renderer. ``renderer::blank`` is a toy renderer that only produces a blank image to the film. The renderer takes ``film`` parameter to specify the film to output the image, and ``color`` parameter for the background color.
#
# A reference to the other asset as a parameter can be passed using component locator. Here we use ``film.loc()`` to get a locator of the film. Althernaively, you can directly pass the instance of the asset directly as a parameter.
# -
renderer = lm.load_renderer(
'renderer',
'blank',
output=film, # or alternatively, film.loc()
color=[1, 1, 1])
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# :cpp:func:`lm::Renderer::render` function executes rendering.
# -
renderer.render()
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# After rendering, the generated image is kept in ``film``. :cpp:func:`lm::Film::save` function outputs this film to the disk as an image.
# -
film.save('blank.png')
'up': [0, 1, 0],
'vfov': 30
})
material = lm.load_material('material_white', 'diffuse', {'Kd': [1, 1, 1]})
film = lm.load_film('film_output', 'bitmap', {'w': 1920, 'h': 1080})
accel = lm.load_accel('accel', 'nanort', {})
scene = lm.load_scene('scene', 'default', {'accel': accel.loc()})
renderer = lm.load_renderer(
'renderer', 'raycast', {
'scene': scene.loc(),
'output': film.loc(),
'visualize_normal': True,
'bg_color': [1, 1, 1]
})
# -
# ### Without instancing
# +
scene.reset()
scene.add_primitive({'camera': camera.loc()})
for y in np.linspace(-10, 10, 10):
for x in np.linspace(-10, 10, 10):
p = scene.create_primitive_node({
'mesh': mesh.loc(),
