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(),