def __init__(self):
self.mouse_model = gui.SceneWidget.Controls.ROTATE_CAMERA
self.bg_color = gui.Color(1, 1, 1)
self.show_skybox = False
self.show_axes = False
self.use_ibl = True
self.use_sun = True
self.new_ibl_name = None # clear to None after loading
self.ibl_intensity = 45000
self.sun_intensity = 45000
self.sun_dir = [0.577, -0.577, -0.577]
self.sun_color = gui.Color(1, 1, 1)
self.apply_material = True # clear to False after processing
self._materials = {
Settings.LIT: rendering.Material(),
Settings.UNLIT: rendering.Material(),
Settings.NORMALS: rendering.Material(),
Settings.DEPTH: rendering.Material()
}
self._materials[Settings.LIT].base_color = [0.9, 0.9, 0.9, 1.0]
self._materials[Settings.LIT].shader = Settings.LIT
self._materials[Settings.UNLIT].base_color = [0.9, 0.9, 0.9, 1.0]
self._materials[Settings.UNLIT].shader = Settings.UNLIT
self._materials[Settings.NORMALS].shader = Settings.NORMALS
self._materials[Settings.DEPTH].shader = Settings.DEPTH
# Conveniently, assigning from self._materials[...] assigns a reference,
# not a copy, so if we change the property of a material, then switch
# to another one, then come back, the old setting will still be there.
self.material = self._materials[Settings.LIT]
def main():
render = rendering.OffscreenRenderer(640, 480)
yellow = rendering.Material()
yellow.base_color = [1.0, 0.75, 0.0, 1.0]
yellow.shader = "defaultLit"
green = rendering.Material()
green.base_color = [0.0, 0.5, 0.0, 1.0]
green.shader = "defaultLit"
grey = rendering.Material()
grey.base_color = [0.7, 0.7, 0.7, 1.0]
grey.shader = "defaultLit"
white = rendering.Material()
white.base_color = [1.0, 1.0, 1.0, 1.0]
white.shader = "defaultLit"
cyl = o3d.geometry.TriangleMesh.create_cylinder(.05, 3)
cyl.compute_vertex_normals()
cyl.translate([-2, 0, 1.5])
sphere = o3d.geometry.TriangleMesh.create_sphere(.2)
sphere.compute_vertex_normals()
sphere.translate([-2, 0, 3])
box = o3d.geometry.TriangleMesh.create_box(2, 2, 1)
box.compute_vertex_normals()
box.translate([-1, -1, 0])
solid = o3d.geometry.TriangleMesh.create_icosahedron(0.5)
solid.compute_triangle_normals()
solid.compute_vertex_normals()
solid.translate([0, 0, 1.75])
render.scene.add_geometry("cyl", cyl, green)
render.scene.add_geometry("sphere", sphere, yellow)
render.scene.add_geometry("box", box, grey)
render.scene.add_geometry("solid", solid, white)
render.setup_camera(60.0, [0, 0, 0], [0, 10, 0], [0, 0, 1])
render.scene.scene.set_sun_light([0.707, 0.0, -.707], [1.0, 1.0, 1.0],
75000)
render.scene.scene.enable_sun_light(True)
render.scene.show_axes(True)
img = render.render_to_image()
o3d.io.write_image("/tmp/test.png", img, 9)
render.setup_camera(60.0, [0, 0, 0], [0, 10, 0], [0, 0, 1])
img = render.render_to_image()
o3d.io.write_image("/tmp/test2.png", img, 9)
def __init__(self, cloud):
# We will create a SceneWidget that fills the entire window, and then
# a label in the lower left on top of the SceneWidget to display the
# coordinate.
app = gui.Application.instance
self.window = app.create_window("Open3D - GetCoord Example", 1024, 768)
# Since we want the label on top of the scene, we cannot use a layout,
# so we need to manually layout the window's children.
self.window.set_on_layout(self._on_layout)
self.widget3d = gui.SceneWidget()
self.window.add_child(self.widget3d)
self.info = gui.Label("")
self.info.visible = False
self.window.add_child(self.info)
self.widget3d.scene = rendering.Open3DScene(self.window.renderer)
mat = rendering.Material()
mat.shader = "defaultUnlit"
# Point size is in native pixels, but "pixel" means different things to
# different platforms (macOS, in particular), so multiply by Window scale
# factor.
mat.point_size = 3 * self.window.scaling
self.widget3d.scene.add_geometry("Point Cloud", cloud, mat)
bounds = self.widget3d.scene.bounding_box
center = bounds.get_center()
self.widget3d.setup_camera(60, bounds, center)
self.widget3d.look_at(center, center - [0, 0, 3], [0, -1, 0])
self.widget3d.set_on_mouse(self._on_mouse_widget3d)
def __init__(self):
self.rgb_images = []
for f in os.listdir(RGB_DIR):
if f.endswith(".jpg") or f.endswith(".png"):
img = o3d.io.read_image(os.path.join(RGB_DIR, f))
self.rgb_images.append(img)
self.depth_images = []
for f in os.listdir(DEPTH_DIR):
if f.endswith(".jpg") or f.endswith(".png"):
img = o3d.io.read_image(os.path.join(DEPTH_DIR, f))
# The images are pretty dark, so rescale them so that it is
# obvious that this is a depth image, for the sake of the example
img = rescale_greyscale(img)
self.depth_images.append(img)
assert (len(self.rgb_images) == len(self.depth_images))
self.window = gui.Application.instance.create_window(
"Open3D - Video Example", 1000, 500)
self.window.set_on_layout(self._on_layout)
self.window.set_on_close(self._on_close)
self.widget3d = gui.SceneWidget()
self.widget3d.scene = rendering.Open3DScene(self.window.renderer)
self.window.add_child(self.widget3d)
lit = rendering.Material()
lit.shader = "defaultLit"
tet = o3d.geometry.TriangleMesh.create_tetrahedron()
tet.compute_vertex_normals()
tet.paint_uniform_color([0.5, 0.75, 1.0])
self.widget3d.scene.add_geometry("tetrahedron", tet, lit)
bounds = self.widget3d.scene.bounding_box
self.widget3d.setup_camera(60.0, bounds, bounds.get_center())
self.widget3d.scene.show_axes(True)
em = self.window.theme.font_size
margin = 0.5 * em
self.panel = gui.Vert(0.5 * em, gui.Margins(margin))
self.panel.add_child(gui.Label("Color image"))
self.rgb_widget = gui.ImageWidget(self.rgb_images[0])
self.panel.add_child(self.rgb_widget)
self.panel.add_child(gui.Label("Depth image (normalized)"))
self.depth_widget = gui.ImageWidget(self.depth_images[0])
self.panel.add_child(self.depth_widget)
self.window.add_child(self.panel)
self.is_done = False
threading.Thread(target=self._update_thread).start()
def add_sphere(self):
self._id += 1
mat = rendering.Material()
mat.base_color = [
random.random(),
random.random(),
random.random(), 1.0
]
mat.shader = "defaultLit"
sphere = o3d.geometry.TriangleMesh.create_sphere(0.5)
sphere.compute_vertex_normals()
sphere.translate([
10.0 * random.uniform(-1.0, 1.0), 10.0 * random.uniform(-1.0, 1.0),
10.0 * random.uniform(-1.0, 1.0)
])
self.scene.scene.add_geometry("sphere" + str(self._id), sphere, mat)
def low_level():
app = gui.Application.instance
app.initialize()
points = make_point_cloud(100, (0, 0, 0), 1.0)
w = app.create_window("Open3D - 3D Text", 1024, 768)
widget3d = gui.SceneWidget()
widget3d.scene = rendering.Open3DScene(w.renderer)
mat = rendering.Material()
mat.shader = "defaultUnlit"
mat.point_size = 5 * w.scaling
widget3d.scene.add_geometry("Points", points, mat)
for idx in range(0, len(points.points)):
widget3d.add_3d_label(points.points[idx], "{}".format(idx))
bbox = widget3d.scene.bounding_box
widget3d.setup_camera(60.0, bbox, bbox.get_center())
w.add_child(widget3d)
app.run()
