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, 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_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())
# -
lm.info()
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# Next we define `assets` necessary to execute renderer, like materials, meshes, etc. In this example, we only need a `film` to which the renderer outputs the image. We can define assets by ``lm::load_*`` function, where ``*`` represents the name of the asset. In this example, we want to make ``film`` asset. So we use :cpp:func:`lm::load_film` function.
#
# The first argument (``film``) specifies id of the asset to be referenced. The second argument (``bitmap``) is given as the type of the assets.
# The optional keyword arguments specify the parameters passed to the instance.
#
# For convenicence, we will refer to the asset of the specific type in ``<asset type>::<name>`` format. For instance, ``film::bitmap`` represents a `bitmap film` asset. ``film::bitmap`` takes two parameters ``w`` and ``h`` which respectively specify width and height of the film.
#
# This function returns a reference to the asset. You can access the underlying member functions. You can find details in :ref:`api_ref`.
# -
film = lm.load_film('film', 'bitmap', w=1920, h=1080)
# + {"raw_mimetype": "text/restructuredtext", "active": ""}
# The created instance of the asset is internally managed by the framework.
# 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.
# -
lm.attach_to_debugger()
lm.init()
if not lm.Release:
lm.parallel.init('openmp', {'num_threads': 1})
lm.log.init('jupyter')
lm.progress.init('jupyter')
lm.info()
lm.comp.load_plugin(os.path.join(env.bin_path, 'accel_embree'))
accel = lm.load_accel('accel', 'embree', {})
scene = lm.load_scene('scene', 'default', {'accel': accel.loc()})
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
# +
# Custom material
material = lm.load_material('visualize_normal_mat', 'visualize_normal', {})
# OBJ model
model = lm.load_model(
'obj1', 'wavefrontobj', {
'path': os.path.join(env.scene_path,
'fireplace_room/fireplace_room.obj'),
'base_material': material.loc()
})
# +
# Film for the rendered image
film = lm.load_film('film1', 'bitmap', {'w': 1920, 'h': 1080})
# Pinhole camera
camera = lm.load_camera(
'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()})
center=[4.167568, 1.078925, -2.397892],
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()
# No output in Jupyter notebook
lm.info()
# Initialize the logger with logger::jupyter
lm.log.init('jupyter')
lm.info()
# ### Wrong asset name
#
# If you specify the wrong asset name, the framework will rause an exception.
try:
# Wrong: bitmapp
lm.load_film('film1', 'bitmapp', w=1920, h=1080)
except Exception:
traceback.print_exc()
# Correct: bitmap
lm.load_film('film1', 'bitmap', w=1920, h=1080)
# ### Invalid parameter
#
# The framework will cause an exception if you try to create an asset with invalid parameters.
# The framework will *not* generate an error for the unnecessasry parameters.
try:
# vfov is missing
lm.load_camera('camera1',
'pinhole',
