Visualization¶
add_geometry.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import open3d as o3d
import open3d.visualization.gui as gui
import open3d.visualization.rendering as rendering
import platform
import random
import threading
import time
isMacOS = (platform.system() == "Darwin")
# This example shows two methods of adding geometry to an existing scene.
# 1) add via a UI callback (in this case a menu, but a button would be similar,
# you would call `button.set_on_clicked(self.on_menu_sphere_)` when
# configuring the button. See `on_menu_sphere()`.
# 2) add asynchronously by polling from another thread. GUI functions must be
# called from the UI thread, so use Application.post_to_main_thread().
# See `on_menu_random()`.
# Running the example will show a simple window with a Debug menu item with the
# two different options. The second method will add random spheres for
# 20 seconds, during which time you can be interacting with the scene, rotating,
# etc.
class SpheresApp:
MENU_SPHERE = 1
MENU_RANDOM = 2
MENU_QUIT = 3
def __init__(self):
self._id = 0
self.window = gui.Application.instance.create_window(
"Add Spheres Example", 1024, 768)
self.scene = gui.SceneWidget()
self.scene.scene = rendering.Open3DScene(self.window.renderer)
self.scene.scene.set_background([1, 1, 1, 1])
self.scene.scene.scene.set_sun_light(
[-1, -1, -1], # direction
[1, 1, 1], # color
100000) # intensity
self.scene.scene.scene.enable_sun_light(True)
bbox = o3d.geometry.AxisAlignedBoundingBox([-10, -10, -10],
[10, 10, 10])
self.scene.setup_camera(60, bbox, [0, 0, 0])
self.window.add_child(self.scene)
# The menu is global (because the macOS menu is global), so only create
# it once, no matter how many windows are created
if gui.Application.instance.menubar is None:
if isMacOS:
app_menu = gui.Menu()
app_menu.add_item("Quit", SpheresApp.MENU_QUIT)
debug_menu = gui.Menu()
debug_menu.add_item("Add Sphere", SpheresApp.MENU_SPHERE)
debug_menu.add_item("Add Random Spheres", SpheresApp.MENU_RANDOM)
if not isMacOS:
debug_menu.add_separator()
debug_menu.add_item("Quit", SpheresApp.MENU_QUIT)
menu = gui.Menu()
if isMacOS:
# macOS will name the first menu item for the running application
# (in our case, probably "Python"), regardless of what we call
# it. This is the application menu, and it is where the
# About..., Preferences..., and Quit menu items typically go.
menu.add_menu("Example", app_menu)
menu.add_menu("Debug", debug_menu)
else:
menu.add_menu("Debug", debug_menu)
gui.Application.instance.menubar = menu
# The menubar is global, but we need to connect the menu items to the
# window, so that the window can call the appropriate function when the
# menu item is activated.
self.window.set_on_menu_item_activated(SpheresApp.MENU_SPHERE,
self._on_menu_sphere)
self.window.set_on_menu_item_activated(SpheresApp.MENU_RANDOM,
self._on_menu_random)
self.window.set_on_menu_item_activated(SpheresApp.MENU_QUIT,
self._on_menu_quit)
def add_sphere(self):
self._id += 1
mat = rendering.MaterialRecord()
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 _on_menu_sphere(self):
# GUI callbacks happen on the main thread, so we can do everything
# normally here.
self.add_sphere()
def _on_menu_random(self):
# This adds spheres asynchronously. This pattern is useful if you have
# data coming in from another source than user interaction.
def thread_main():
for _ in range(0, 20):
# We can only modify GUI objects on the main thread, so we
# need to post the function to call to the main thread.
gui.Application.instance.post_to_main_thread(
self.window, self.add_sphere)
time.sleep(1)
threading.Thread(target=thread_main).start()
def _on_menu_quit(self):
gui.Application.instance.quit()
def main():
gui.Application.instance.initialize()
SpheresApp()
gui.Application.instance.run()
if __name__ == "__main__":
main()
|
all_widgets.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import open3d.visualization.gui as gui
import os.path
basedir = os.path.dirname(os.path.realpath(__file__))
class ExampleWindow:
MENU_CHECKABLE = 1
MENU_DISABLED = 2
MENU_QUIT = 3
def __init__(self):
self.window = gui.Application.instance.create_window("Test", 400, 768)
# self.window = gui.Application.instance.create_window("Test", 400, 768,
# x=50, y=100)
w = self.window # for more concise code
# Rather than specifying sizes in pixels, which may vary in size based
# on the monitor, especially on macOS which has 220 dpi monitors, use
# the em-size. This way sizings will be proportional to the font size,
# which will create a more visually consistent size across platforms.
em = w.theme.font_size
# Widgets are laid out in layouts: gui.Horiz, gui.Vert,
# gui.CollapsableVert, and gui.VGrid. By nesting the layouts we can
# achieve complex designs. Usually we use a vertical layout as the
# topmost widget, since widgets tend to be organized from top to bottom.
# Within that, we usually have a series of horizontal layouts for each
# row.
layout = gui.Vert(0, gui.Margins(0.5 * em, 0.5 * em, 0.5 * em,
0.5 * em))
# Create the menu. The menu is global (because the macOS menu is global),
# so only create it once.
if gui.Application.instance.menubar is None:
menubar = gui.Menu()
test_menu = gui.Menu()
test_menu.add_item("An option", ExampleWindow.MENU_CHECKABLE)
test_menu.set_checked(ExampleWindow.MENU_CHECKABLE, True)
test_menu.add_item("Unavailable feature",
ExampleWindow.MENU_DISABLED)
test_menu.set_enabled(ExampleWindow.MENU_DISABLED, False)
test_menu.add_separator()
test_menu.add_item("Quit", ExampleWindow.MENU_QUIT)
# On macOS the first menu item is the application menu item and will
# always be the name of the application (probably "Python"),
# regardless of what you pass in here. The application menu is
# typically where About..., Preferences..., and Quit go.
menubar.add_menu("Test", test_menu)
gui.Application.instance.menubar = menubar
# Each window needs to know what to do with the menu items, so we need
# to tell the window how to handle menu items.
w.set_on_menu_item_activated(ExampleWindow.MENU_CHECKABLE,
self._on_menu_checkable)
w.set_on_menu_item_activated(ExampleWindow.MENU_QUIT,
self._on_menu_quit)
# Create a file-chooser widget. One part will be a text edit widget for
# the filename and clicking on the button will let the user choose using
# the file dialog.
self._fileedit = gui.TextEdit()
filedlgbutton = gui.Button("...")
filedlgbutton.horizontal_padding_em = 0.5
filedlgbutton.vertical_padding_em = 0
filedlgbutton.set_on_clicked(self._on_filedlg_button)
# (Create the horizontal widget for the row. This will make sure the
# text editor takes up as much space as it can.)
fileedit_layout = gui.Horiz()
fileedit_layout.add_child(gui.Label("Model file"))
fileedit_layout.add_child(self._fileedit)
fileedit_layout.add_fixed(0.25 * em)
fileedit_layout.add_child(filedlgbutton)
# add to the top-level (vertical) layout
layout.add_child(fileedit_layout)
# Create a collapsable vertical widget, which takes up enough vertical
# space for all its children when open, but only enough for text when
# closed. This is useful for property pages, so the user can hide sets
# of properties they rarely use. All layouts take a spacing parameter,
# which is the spacinging between items in the widget, and a margins
# parameter, which specifies the spacing of the left, top, right,
# bottom margins. (This acts like the 'padding' property in CSS.)
collapse = gui.CollapsableVert("Widgets", 0.33 * em,
gui.Margins(em, 0, 0, 0))
self._label = gui.Label("Lorem ipsum dolor")
self._label.text_color = gui.Color(1.0, 0.5, 0.0)
collapse.add_child(self._label)
# Create a checkbox. Checking or unchecking would usually be used to set
# a binary property, but in this case it will show a simple message box,
# which illustrates how to create simple dialogs.
cb = gui.Checkbox("Enable some really cool effect")
cb.set_on_checked(self._on_cb) # set the callback function
collapse.add_child(cb)
# Create a color editor. We will change the color of the orange label
# above when the color changes.
color = gui.ColorEdit()
color.color_value = self._label.text_color
color.set_on_value_changed(self._on_color)
collapse.add_child(color)
# This is a combobox, nothing fancy here, just set a simple function to
# handle the user selecting an item.
combo = gui.Combobox()
combo.add_item("Show point labels")
combo.add_item("Show point velocity")
combo.add_item("Show bounding boxes")
combo.set_on_selection_changed(self._on_combo)
collapse.add_child(combo)
# This is a toggle switch, which is similar to a checkbox. To my way of
# thinking the difference is subtle: a checkbox toggles properties
# (for example, purely visual changes like enabling lighting) while a
# toggle switch is better for changing the behavior of the app (for
# example, turning on processing from the camera).
switch = gui.ToggleSwitch("Continuously update from camera")
switch.set_on_clicked(self._on_switch)
collapse.add_child(switch)
self.logo_idx = 0
proxy = gui.WidgetProxy()
def switch_proxy():
self.logo_idx += 1
if self.logo_idx % 3 == 0:
proxy.set_widget(None)
elif self.logo_idx % 3 == 1:
# Add a simple image
logo = gui.ImageWidget(basedir + "/icon-32.png")
proxy.set_widget(logo)
else:
label = gui.Label(
'Open3D: A Modern Library for 3D Data Processing')
proxy.set_widget(label)
w.set_needs_layout()
logo_btn = gui.Button('Switch Logo By WidgetProxy')
logo_btn.vertical_padding_em = 0
logo_btn.background_color = gui.Color(r=0, b=0.5, g=0)
logo_btn.set_on_clicked(switch_proxy)
collapse.add_child(logo_btn)
collapse.add_child(proxy)
# Widget stack demo
self._widget_idx = 0
hz = gui.Horiz(spacing=5)
push_widget_btn = gui.Button('Push widget')
push_widget_btn.vertical_padding_em = 0
pop_widget_btn = gui.Button('Pop widget')
pop_widget_btn.vertical_padding_em = 0
stack = gui.WidgetStack()
stack.set_on_top(lambda w: print(f'New widget is: {w.text}'))
hz.add_child(gui.Label('WidgetStack '))
hz.add_child(push_widget_btn)
hz.add_child(pop_widget_btn)
hz.add_child(stack)
collapse.add_child(hz)
def push_widget():
self._widget_idx += 1
stack.push_widget(gui.Label(f'Widget {self._widget_idx}'))
push_widget_btn.set_on_clicked(push_widget)
pop_widget_btn.set_on_clicked(stack.pop_widget)
# Add a list of items
lv = gui.ListView()
lv.set_items(["Ground", "Trees", "Buildings", "Cars", "People", "Cats"])
lv.selected_index = lv.selected_index + 2 # initially is -1, so now 1
lv.set_max_visible_items(4)
lv.set_on_selection_changed(self._on_list)
collapse.add_child(lv)
# Add a tree view
tree = gui.TreeView()
tree.add_text_item(tree.get_root_item(), "Camera")
geo_id = tree.add_text_item(tree.get_root_item(), "Geometries")
mesh_id = tree.add_text_item(geo_id, "Mesh")
tree.add_text_item(mesh_id, "Triangles")
tree.add_text_item(mesh_id, "Albedo texture")
tree.add_text_item(mesh_id, "Normal map")
points_id = tree.add_text_item(geo_id, "Points")
tree.can_select_items_with_children = True
tree.set_on_selection_changed(self._on_tree)
# does not call on_selection_changed: user did not change selection
tree.selected_item = points_id
collapse.add_child(tree)
# Add two number editors, one for integers and one for floating point
# Number editor can clamp numbers to a range, although this is more
# useful for integers than for floating point.
intedit = gui.NumberEdit(gui.NumberEdit.INT)
intedit.int_value = 0
intedit.set_limits(1, 19) # value coerced to 1
intedit.int_value = intedit.int_value + 2 # value should be 3
doubleedit = gui.NumberEdit(gui.NumberEdit.DOUBLE)
numlayout = gui.Horiz()
numlayout.add_child(gui.Label("int"))
numlayout.add_child(intedit)
numlayout.add_fixed(em) # manual spacing (could set it in Horiz() ctor)
numlayout.add_child(gui.Label("double"))
numlayout.add_child(doubleedit)
collapse.add_child(numlayout)
# Create a progress bar. It ranges from 0.0 to 1.0.
self._progress = gui.ProgressBar()
self._progress.value = 0.25 # 25% complete
self._progress.value = self._progress.value + 0.08 # 0.25 + 0.08 = 33%
prog_layout = gui.Horiz(em)
prog_layout.add_child(gui.Label("Progress..."))
prog_layout.add_child(self._progress)
collapse.add_child(prog_layout)
# Create a slider. It acts very similar to NumberEdit except that the
# user moves a slider and cannot type the number.
slider = gui.Slider(gui.Slider.INT)
slider.set_limits(5, 13)
slider.set_on_value_changed(self._on_slider)
collapse.add_child(slider)
# Create a text editor. The placeholder text (if not empty) will be
# displayed when there is no text, as concise help, or visible tooltip.
tedit = gui.TextEdit()
tedit.placeholder_text = "Edit me some text here"
# on_text_changed fires whenever the user changes the text (but not if
# the text_value property is assigned to).
tedit.set_on_text_changed(self._on_text_changed)
# on_value_changed fires whenever the user signals that they are finished
# editing the text, either by pressing return or by clicking outside of
# the text editor, thus losing text focus.
tedit.set_on_value_changed(self._on_value_changed)
collapse.add_child(tedit)
# Create a widget for showing/editing a 3D vector
vedit = gui.VectorEdit()
vedit.vector_value = [1, 2, 3]
vedit.set_on_value_changed(self._on_vedit)
collapse.add_child(vedit)
# Create a VGrid layout. This layout specifies the number of columns
# (two, in this case), and will place the first child in the first
# column, the second in the second, the third in the first, the fourth
# in the second, etc.
# So:
# 2 cols 3 cols 4 cols
# | 1 | 2 | | 1 | 2 | 3 | | 1 | 2 | 3 | 4 |
# | 3 | 4 | | 4 | 5 | 6 | | 5 | 6 | 7 | 8 |
# | 5 | 6 | | 7 | 8 | 9 | | 9 | 10 | 11 | 12 |
# | ... | | ... | | ... |
vgrid = gui.VGrid(2)
vgrid.add_child(gui.Label("Trees"))
vgrid.add_child(gui.Label("12 items"))
vgrid.add_child(gui.Label("People"))
vgrid.add_child(gui.Label("2 (93% certainty)"))
vgrid.add_child(gui.Label("Cars"))
vgrid.add_child(gui.Label("5 (87% certainty)"))
collapse.add_child(vgrid)
# Create a tab control. This is really a set of N layouts on top of each
# other, but with only one selected.
tabs = gui.TabControl()
tab1 = gui.Vert()
tab1.add_child(gui.Checkbox("Enable option 1"))
tab1.add_child(gui.Checkbox("Enable option 2"))
tab1.add_child(gui.Checkbox("Enable option 3"))
tabs.add_tab("Options", tab1)
tab2 = gui.Vert()
tab2.add_child(gui.Label("No plugins detected"))
tab2.add_stretch()
tabs.add_tab("Plugins", tab2)
collapse.add_child(tabs)
# Quit button. (Typically this is a menu item)
button_layout = gui.Horiz()
ok_button = gui.Button("Ok")
ok_button.set_on_clicked(self._on_ok)
button_layout.add_stretch()
button_layout.add_child(ok_button)
layout.add_child(collapse)
layout.add_child(button_layout)
# We're done, set the window's layout
w.add_child(layout)
def _on_filedlg_button(self):
filedlg = gui.FileDialog(gui.FileDialog.OPEN, "Select file",
self.window.theme)
filedlg.add_filter(".obj .ply .stl", "Triangle mesh (.obj, .ply, .stl)")
filedlg.add_filter("", "All files")
filedlg.set_on_cancel(self._on_filedlg_cancel)
filedlg.set_on_done(self._on_filedlg_done)
self.window.show_dialog(filedlg)
def _on_filedlg_cancel(self):
self.window.close_dialog()
def _on_filedlg_done(self, path):
self._fileedit.text_value = path
self.window.close_dialog()
def _on_cb(self, is_checked):
if is_checked:
text = "Sorry, effects are unimplemented"
else:
text = "Good choice"
self.show_message_dialog("There might be a problem...", text)
def _on_switch(self, is_on):
if is_on:
print("Camera would now be running")
else:
print("Camera would now be off")
# This function is essentially the same as window.show_message_box(),
# so for something this simple just use that, but it illustrates making a
# dialog.
def show_message_dialog(self, title, message):
# A Dialog is just a widget, so you make its child a layout just like
# a Window.
dlg = gui.Dialog(title)
# Add the message text
em = self.window.theme.font_size
dlg_layout = gui.Vert(em, gui.Margins(em, em, em, em))
dlg_layout.add_child(gui.Label(message))
# Add the Ok button. We need to define a callback function to handle
# the click.
ok_button = gui.Button("Ok")
ok_button.set_on_clicked(self._on_dialog_ok)
# We want the Ok button to be an the right side, so we need to add
# a stretch item to the layout, otherwise the button will be the size
# of the entire row. A stretch item takes up as much space as it can,
# which forces the button to be its minimum size.
button_layout = gui.Horiz()
button_layout.add_stretch()
button_layout.add_child(ok_button)
# Add the button layout,
dlg_layout.add_child(button_layout)
# ... then add the layout as the child of the Dialog
dlg.add_child(dlg_layout)
# ... and now we can show the dialog
self.window.show_dialog(dlg)
def _on_dialog_ok(self):
self.window.close_dialog()
def _on_color(self, new_color):
self._label.text_color = new_color
def _on_combo(self, new_val, new_idx):
print(new_idx, new_val)
def _on_list(self, new_val, is_dbl_click):
print(new_val)
def _on_tree(self, new_item_id):
print(new_item_id)
def _on_slider(self, new_val):
self._progress.value = new_val / 20.0
def _on_text_changed(self, new_text):
print("edit:", new_text)
def _on_value_changed(self, new_text):
print("value:", new_text)
def _on_vedit(self, new_val):
print(new_val)
def _on_ok(self):
gui.Application.instance.quit()
def _on_menu_checkable(self):
gui.Application.instance.menubar.set_checked(
ExampleWindow.MENU_CHECKABLE,
not gui.Application.instance.menubar.is_checked(
ExampleWindow.MENU_CHECKABLE))
def _on_menu_quit(self):
gui.Application.instance.quit()
# This class is essentially the same as window.show_message_box(),
# so for something this simple just use that, but it illustrates making a
# dialog.
class MessageBox:
def __init__(self, title, message):
self._window = None
# A Dialog is just a widget, so you make its child a layout just like
# a Window.
dlg = gui.Dialog(title)
# Add the message text
em = self.window.theme.font_size
dlg_layout = gui.Vert(em, gui.Margins(em, em, em, em))
dlg_layout.add_child(gui.Label(message))
# Add the Ok button. We need to define a callback function to handle
# the click.
ok_button = gui.Button("Ok")
ok_button.set_on_clicked(self._on_ok)
# We want the Ok button to be an the right side, so we need to add
# a stretch item to the layout, otherwise the button will be the size
# of the entire row. A stretch item takes up as much space as it can,
# which forces the button to be its minimum size.
button_layout = gui.Horiz()
button_layout.add_stretch()
button_layout.add_child(ok_button)
# Add the button layout,
dlg_layout.add_child(button_layout)
# ... then add the layout as the child of the Dialog
dlg.add_child(dlg_layout)
def show(self, window):
self._window = window
def _on_ok(self):
self._window.close_dialog()
def main():
# We need to initalize the application, which finds the necessary shaders for
# rendering and prepares the cross-platform window abstraction.
gui.Application.instance.initialize()
w = ExampleWindow()
# Run the event loop. This will not return until the last window is closed.
gui.Application.instance.run()
if __name__ == "__main__":
main()
|
customized_visualization.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import os
import open3d as o3d
import numpy as np
import matplotlib.pyplot as plt
pyexample_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
test_data_path = os.path.join(os.path.dirname(pyexample_path), 'test_data')
def custom_draw_geometry(pcd):
# The following code achieves the same effect as:
# o3d.visualization.draw_geometries([pcd])
vis = o3d.visualization.Visualizer()
vis.create_window()
vis.add_geometry(pcd)
vis.run()
vis.destroy_window()
def custom_draw_geometry_with_custom_fov(pcd, fov_step):
vis = o3d.visualization.Visualizer()
vis.create_window()
vis.add_geometry(pcd)
ctr = vis.get_view_control()
print("Field of view (before changing) %.2f" % ctr.get_field_of_view())
ctr.change_field_of_view(step=fov_step)
print("Field of view (after changing) %.2f" % ctr.get_field_of_view())
vis.run()
vis.destroy_window()
def custom_draw_geometry_with_rotation(pcd):
def rotate_view(vis):
ctr = vis.get_view_control()
ctr.rotate(10.0, 0.0)
return False
o3d.visualization.draw_geometries_with_animation_callback([pcd],
rotate_view)
def custom_draw_geometry_load_option(pcd):
vis = o3d.visualization.Visualizer()
vis.create_window()
vis.add_geometry(pcd)
vis.get_render_option().load_from_json(
os.path.join(test_data_path, 'renderoption.json'))
vis.run()
vis.destroy_window()
def custom_draw_geometry_with_key_callback(pcd):
def change_background_to_black(vis):
opt = vis.get_render_option()
opt.background_color = np.asarray([0, 0, 0])
return False
def load_render_option(vis):
vis.get_render_option().load_from_json(
os.path.join(test_data_path, 'renderoption.json'))
return False
def capture_depth(vis):
depth = vis.capture_depth_float_buffer()
plt.imshow(np.asarray(depth))
plt.show()
return False
def capture_image(vis):
image = vis.capture_screen_float_buffer()
plt.imshow(np.asarray(image))
plt.show()
return False
key_to_callback = {}
key_to_callback[ord("K")] = change_background_to_black
key_to_callback[ord("R")] = load_render_option
key_to_callback[ord(",")] = capture_depth
key_to_callback[ord(".")] = capture_image
o3d.visualization.draw_geometries_with_key_callbacks([pcd], key_to_callback)
def custom_draw_geometry_with_camera_trajectory(pcd):
custom_draw_geometry_with_camera_trajectory.index = -1
custom_draw_geometry_with_camera_trajectory.trajectory =\
o3d.io.read_pinhole_camera_trajectory(
os.path.join(test_data_path, 'camera_trajectory.json'))
custom_draw_geometry_with_camera_trajectory.vis = o3d.visualization.Visualizer(
)
image_path = os.path.join(test_data_path, 'image')
if not os.path.exists(image_path):
os.makedirs(image_path)
depth_path = os.path.join(test_data_path, 'depth')
if not os.path.exists(depth_path):
os.makedirs(depth_path)
render_option_path = os.path.join(test_data_path, 'renderoption.json')
def move_forward(vis):
# This function is called within the o3d.visualization.Visualizer::run() loop
# The run loop calls the function, then re-render
# So the sequence in this function is to:
# 1. Capture frame
# 2. index++, check ending criteria
# 3. Set camera
# 4. (Re-render)
ctr = vis.get_view_control()
glb = custom_draw_geometry_with_camera_trajectory
if glb.index >= 0:
print("Capture image {:05d}".format(glb.index))
depth = vis.capture_depth_float_buffer(False)
image = vis.capture_screen_float_buffer(False)
plt.imsave(os.path.join(depth_path, '{:05d}.png'.format(glb.index)),\
np.asarray(depth), dpi = 1)
plt.imsave(os.path.join(image_path, '{:05d}.png'.format(glb.index)),\
np.asarray(image), dpi = 1)
# vis.capture_depth_image("depth/{:05d}.png".format(glb.index), False)
# vis.capture_screen_image("image/{:05d}.png".format(glb.index), False)
glb.index = glb.index + 1
if glb.index < len(glb.trajectory.parameters):
ctr.convert_from_pinhole_camera_parameters(
glb.trajectory.parameters[glb.index], allow_arbitrary=True)
else:
custom_draw_geometry_with_camera_trajectory.vis.\
register_animation_callback(None)
return False
vis = custom_draw_geometry_with_camera_trajectory.vis
vis.create_window()
vis.add_geometry(pcd)
vis.get_render_option().load_from_json(render_option_path)
vis.register_animation_callback(move_forward)
vis.run()
vis.destroy_window()
if __name__ == "__main__":
pcd_data = o3d.data.PCDPointCloud()
pcd = o3d.io.read_point_cloud(pcd_data.path)
print("1. Customized visualization to mimic DrawGeometry")
custom_draw_geometry(pcd)
print("2. Changing field of view")
custom_draw_geometry_with_custom_fov(pcd, 90.0)
custom_draw_geometry_with_custom_fov(pcd, -90.0)
print("3. Customized visualization with a rotating view")
custom_draw_geometry_with_rotation(pcd)
print("4. Customized visualization showing normal rendering")
custom_draw_geometry_load_option(pcd)
print("5. Customized visualization with key press callbacks")
print(" Press 'K' to change background color to black")
print(" Press 'R' to load a customized render option, showing normals")
print(" Press ',' to capture the depth buffer and show it")
print(" Press '.' to capture the screen and show it")
custom_draw_geometry_with_key_callback(pcd)
print("6. Customized visualization playing a camera trajectory")
custom_draw_geometry_with_camera_trajectory(pcd)
|
customized_visualization_key_action.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import open3d as o3d
def custom_key_action_without_kb_repeat_delay(pcd):
rotating = False
vis = o3d.visualization.VisualizerWithKeyCallback()
def key_action_callback(vis, action, mods):
nonlocal rotating
print(action)
if action == 1: # key down
rotating = True
elif action == 0: # key up
rotating = False
elif action == 2: # key repeat
pass
return True
def animation_callback(vis):
nonlocal rotating
if rotating:
ctr = vis.get_view_control()
ctr.rotate(10.0, 0.0)
# key_action_callback will be triggered when there's a keyboard press, release or repeat event
vis.register_key_action_callback(32, key_action_callback) # space
# animation_callback is always repeatedly called by the visualizer
vis.register_animation_callback(animation_callback)
vis.create_window()
vis.add_geometry(pcd)
vis.run()
if __name__ == "__main__":
ply_data = o3d.data.PLYPointCloud()
pcd = o3d.io.read_point_cloud(ply_data.path)
print(
"Customized visualization with smooth key action (without keyboard repeat delay)"
)
custom_key_action_without_kb_repeat_delay(pcd)
|
demo_scene.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
"""Demo scene demonstrating models, built-in shapes, and materials"""
import math
import numpy as np
import os
import open3d as o3d
import open3d.visualization as vis
# Check for assets
def check_for_required_assets():
'''
Check for demo scene assets and print usage if necessary
'''
if not os.path.exists("examples/test_data/demo_scene_assets"):
print("""This demo requires assets that appear to be missing.
Please execute the follow commands:
```
cd examples/test_data
wget https://github.com/isl-org/open3d_downloads/releases/download/o3d_demo_scene/demo_scene_assets.tgz
tar xzvf demo_scene_assets.tgz
cd ../..
python examples/python/visualization/demo_scene.py
```
""")
exit(1)
def create_material(directory, name):
'''
Convenience function for creating material and loading a set of associated shaders
'''
mat = vis.Material('defaultLit')
# Color, Roughness and Normal textures are always present
mat.texture_maps['albedo'] = o3d.t.io.read_image(
os.path.join(directory, name + '_Color.jpg'))
mat.texture_maps['roughness'] = o3d.t.io.read_image(
os.path.join(directory, name + '_Roughness.jpg'))
mat.texture_maps['normal'] = o3d.t.io.read_image(
os.path.join(directory, name + '_NormalDX.jpg'))
# Ambient occlusion and metal textures are not always available
# NOTE: Checking for their existence is not necessary but checking first
# avoids annoying warning output
ao_img_name = os.path.join(directory, name + '_AmbientOcclusion.jpg')
metallic_img_name = os.path.join(directory, name + '_Metalness.jpg')
if os.path.exists(ao_img_name):
mat.texture_maps['ambient_occlusion'] = o3d.t.io.read_image(ao_img_name)
if os.path.exists(metallic_img_name):
mat.texture_maps['metallic'] = o3d.t.io.read_image(metallic_img_name)
mat.scalar_properties['metallic'] = 1.0
return mat
def convert_material_record(mat_record):
mat = vis.Material('defaultLit')
# Convert scalar paremeters
mat.vector_properties['base_color'] = mat_record.base_color
mat.scalar_properties['metallic'] = mat_record.base_metallic
mat.scalar_properties['roughness'] = mat_record.base_roughness
mat.scalar_properties['reflectance'] = mat_record.base_reflectance
mat.texture_maps['albedo'] = o3d.t.geometry.Image.from_legacy(
mat_record.albedo_img)
mat.texture_maps['normal'] = o3d.t.geometry.Image.from_legacy(
mat_record.normal_img)
mat.texture_maps['ao_rough_metal'] = o3d.t.geometry.Image.from_legacy(
mat_record.ao_rough_metal_img)
return mat
def create_scene():
'''
Creates the geometry and materials for the demo scene and returns a dictionary suitable for draw call
'''
# Create some shapes for our scene
a_cube = o3d.geometry.TriangleMesh.create_box(2,
4,
4,
create_uv_map=True,
map_texture_to_each_face=True)
a_cube.compute_triangle_normals()
a_cube.translate((-5, 0, -2))
a_cube = o3d.t.geometry.TriangleMesh.from_legacy(a_cube)
a_sphere = o3d.geometry.TriangleMesh.create_sphere(2.5,
resolution=40,
create_uv_map=True)
a_sphere.compute_vertex_normals()
rotate_90 = o3d.geometry.get_rotation_matrix_from_xyz((-math.pi / 2, 0, 0))
a_sphere.rotate(rotate_90)
a_sphere.translate((5, 2.4, 0))
a_sphere = o3d.t.geometry.TriangleMesh.from_legacy(a_sphere)
a_cylinder = o3d.geometry.TriangleMesh.create_cylinder(
1.0, 4.0, 30, 4, True)
a_cylinder.compute_triangle_normals()
a_cylinder.rotate(rotate_90)
a_cylinder.translate((10, 2, 0))
a_cylinder = o3d.t.geometry.TriangleMesh.from_legacy(a_cylinder)
a_ico = o3d.geometry.TriangleMesh.create_icosahedron(1.25,
create_uv_map=True)
a_ico.compute_triangle_normals()
a_ico.translate((-10, 2, 0))
a_ico = o3d.t.geometry.TriangleMesh.from_legacy(a_ico)
# Load an OBJ model for our scene
helmet = o3d.io.read_triangle_model(
"examples/test_data/demo_scene_assets/FlightHelmet.gltf")
helmet_parts = []
for m in helmet.meshes:
# m.mesh.paint_uniform_color((1.0, 0.75, 0.3))
m.mesh.scale(10.0, (0.0, 0.0, 0.0))
helmet_parts.append(m)
# Create a ground plane
ground_plane = o3d.geometry.TriangleMesh.create_box(
50.0, 0.1, 50.0, create_uv_map=True, map_texture_to_each_face=True)
ground_plane.compute_triangle_normals()
rotate_180 = o3d.geometry.get_rotation_matrix_from_xyz((-math.pi, 0, 0))
ground_plane.rotate(rotate_180)
ground_plane.translate((-25.0, -0.1, -25.0))
ground_plane.paint_uniform_color((1, 1, 1))
ground_plane = o3d.t.geometry.TriangleMesh.from_legacy(ground_plane)
# Material to make ground plane more interesting - a rough piece of glass
mat_ground = vis.Material("defaultLitSSR")
mat_ground.scalar_properties['roughness'] = 0.15
mat_ground.scalar_properties['reflectance'] = 0.72
mat_ground.scalar_properties['transmission'] = 0.6
mat_ground.scalar_properties['thickness'] = 0.3
mat_ground.scalar_properties['absorption_distance'] = 0.1
mat_ground.vector_properties['absorption_color'] = np.array(
[0.82, 0.98, 0.972, 1.0])
mat_ground.texture_maps['albedo'] = o3d.t.io.read_image(
"examples/test_data/demo_scene_assets/PaintedPlaster017_Color.jpg")
mat_ground.texture_maps['roughness'] = o3d.t.io.read_image(
"examples/test_data/demo_scene_assets/noiseTexture.png")
mat_ground.texture_maps['normal'] = o3d.t.io.read_image(
"examples/test_data/demo_scene_assets/PaintedPlaster017_NormalDX.jpg")
ground_plane.material = mat_ground
# Load textures and create materials for each of our demo items
a_cube.material = create_material("examples/test_data/demo_scene_assets",
"WoodFloor050")
a_sphere.material = create_material("examples/test_data/demo_scene_assets",
"Tiles074")
a_ico.material = create_material("examples/test_data/demo_scene_assets",
"Terrazzo018")
a_cylinder.material = create_material(
"examples/test_data/demo_scene_assets", "Metal008")
geoms = [{
"name": "plane",
"geometry": ground_plane
}, {
"name": "cube",
"geometry": a_cube
}, {
"name": "cylinder",
"geometry": a_cylinder
}, {
"name": "ico",
"geometry": a_ico
}, {
"name": "sphere",
"geometry": a_sphere
}]
# Load the helmet
for part in helmet_parts:
name = part.mesh_name
tgeom = o3d.t.geometry.TriangleMesh.from_legacy(part.mesh)
tgeom.material = convert_material_record(
helmet.materials[part.material_idx])
geoms.append({"name": name, "geometry": tgeom})
return geoms
if __name__ == "__main__":
check_for_required_assets()
geoms = create_scene()
vis.draw(geoms,
bg_color=(0.8, 0.9, 0.9, 1.0),
show_ui=True,
width=1920,
height=1080)
|
draw.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import math
import numpy as np
import open3d as o3d
import open3d.visualization as vis
import os
import random
pyexample_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
test_data_path = os.path.join(os.path.dirname(pyexample_path), 'test_data')
def normalize(v):
a = 1.0 / math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2])
return (a * v[0], a * v[1], a * v[2])
def make_point_cloud(npts, center, radius, colorize):
pts = np.random.uniform(-radius, radius, size=[npts, 3]) + center
cloud = o3d.geometry.PointCloud()
cloud.points = o3d.utility.Vector3dVector(pts)
if colorize:
colors = np.random.uniform(0.0, 1.0, size=[npts, 3])
cloud.colors = o3d.utility.Vector3dVector(colors)
return cloud
def single_object():
# No colors, no normals, should appear unlit black
cube = o3d.geometry.TriangleMesh.create_box(1, 2, 4)
vis.draw(cube)
def multi_objects():
pc_rad = 1.0
pc_nocolor = make_point_cloud(100, (0, -2, 0), pc_rad, False)
pc_color = make_point_cloud(100, (3, -2, 0), pc_rad, True)
r = 0.4
sphere_unlit = o3d.geometry.TriangleMesh.create_sphere(r)
sphere_unlit.translate((0, 1, 0))
sphere_colored_unlit = o3d.geometry.TriangleMesh.create_sphere(r)
sphere_colored_unlit.paint_uniform_color((1.0, 0.0, 0.0))
sphere_colored_unlit.translate((2, 1, 0))
sphere_lit = o3d.geometry.TriangleMesh.create_sphere(r)
sphere_lit.compute_vertex_normals()
sphere_lit.translate((4, 1, 0))
sphere_colored_lit = o3d.geometry.TriangleMesh.create_sphere(r)
sphere_colored_lit.compute_vertex_normals()
sphere_colored_lit.paint_uniform_color((0.0, 1.0, 0.0))
sphere_colored_lit.translate((6, 1, 0))
big_bbox = o3d.geometry.AxisAlignedBoundingBox((-pc_rad, -3, -pc_rad),
(6.0 + r, 1.0 + r, pc_rad))
big_bbox.color = (0.0, 0.0, 0.0)
sphere_bbox = sphere_unlit.get_axis_aligned_bounding_box()
sphere_bbox.color = (1.0, 0.5, 0.0)
lines = o3d.geometry.LineSet.create_from_axis_aligned_bounding_box(
sphere_lit.get_axis_aligned_bounding_box())
lines.paint_uniform_color((0.0, 1.0, 0.0))
lines_colored = o3d.geometry.LineSet.create_from_axis_aligned_bounding_box(
sphere_colored_lit.get_axis_aligned_bounding_box())
lines_colored.paint_uniform_color((0.0, 0.0, 1.0))
vis.draw([
pc_nocolor, pc_color, sphere_unlit, sphere_colored_unlit, sphere_lit,
sphere_colored_lit, big_bbox, sphere_bbox, lines, lines_colored
])
def actions():
SOURCE_NAME = "Source"
RESULT_NAME = "Result (Poisson reconstruction)"
TRUTH_NAME = "Ground truth"
bunny = o3d.data.BunnyMesh()
bunny_mesh = o3d.io.read_triangle_mesh(bunny.path)
bunny_mesh.compute_vertex_normals()
bunny_mesh.paint_uniform_color((1, 0.75, 0))
bunny_mesh.compute_vertex_normals()
cloud = o3d.geometry.PointCloud()
cloud.points = bunny_mesh.vertices
cloud.normals = bunny_mesh.vertex_normals
def make_mesh(o3dvis):
# TODO: call o3dvis.get_geometry instead of using bunny_mesh
mesh, _ = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(
cloud)
mesh.paint_uniform_color((1, 1, 1))
mesh.compute_vertex_normals()
o3dvis.add_geometry({"name": RESULT_NAME, "geometry": mesh})
o3dvis.show_geometry(SOURCE_NAME, False)
def toggle_result(o3dvis):
truth_vis = o3dvis.get_geometry(TRUTH_NAME).is_visible
o3dvis.show_geometry(TRUTH_NAME, not truth_vis)
o3dvis.show_geometry(RESULT_NAME, truth_vis)
vis.draw([{
"name": SOURCE_NAME,
"geometry": cloud
}, {
"name": TRUTH_NAME,
"geometry": bunny_mesh,
"is_visible": False
}],
actions=[("Create Mesh", make_mesh),
("Toggle truth/result", toggle_result)])
def get_icp_transform(source, target, source_indices, target_indices):
corr = np.zeros((len(source_indices), 2))
corr[:, 0] = source_indices
corr[:, 1] = target_indices
# Estimate rough transformation using correspondences
p2p = o3d.pipelines.registration.TransformationEstimationPointToPoint()
trans_init = p2p.compute_transformation(source, target,
o3d.utility.Vector2iVector(corr))
# Point-to-point ICP for refinement
threshold = 0.03 # 3cm distance threshold
reg_p2p = o3d.pipelines.registration.registration_icp(
source, target, threshold, trans_init,
o3d.pipelines.registration.TransformationEstimationPointToPoint())
return reg_p2p.transformation
def selections():
source = o3d.io.read_point_cloud(
os.path.join(test_data_path, 'ICP', 'cloud_bin_0.pcd'))
target = o3d.io.read_point_cloud(
os.path.join(test_data_path, 'ICP', 'cloud_bin_2.pcd'))
source.paint_uniform_color([1, 0.706, 0])
target.paint_uniform_color([0, 0.651, 0.929])
source_name = "Source (yellow)"
target_name = "Target (blue)"
def do_icp_one_set(o3dvis):
# sets: [name: [{ "index": int, "order": int, "point": (x, y, z)}, ...],
# ...]
sets = o3dvis.get_selection_sets()
source_picked = sorted(list(sets[0][source_name]),
key=lambda x: x.order)
target_picked = sorted(list(sets[0][target_name]),
key=lambda x: x.order)
source_indices = [idx.index for idx in source_picked]
target_indices = [idx.index for idx in target_picked]
t = get_icp_transform(source, target, source_indices, target_indices)
source.transform(t)
# Update the source geometry
o3dvis.remove_geometry(source_name)
o3dvis.add_geometry({"name": source_name, "geometry": source})
def do_icp_two_sets(o3dvis):
sets = o3dvis.get_selection_sets()
source_set = sets[0][source_name]
target_set = sets[1][target_name]
source_picked = sorted(list(source_set), key=lambda x: x.order)
target_picked = sorted(list(target_set), key=lambda x: x.order)
source_indices = [idx.index for idx in source_picked]
target_indices = [idx.index for idx in target_picked]
t = get_icp_transform(source, target, source_indices, target_indices)
source.transform(t)
# Update the source geometry
o3dvis.remove_geometry(source_name)
o3dvis.add_geometry({"name": source_name, "geometry": source})
vis.draw([{
"name": source_name,
"geometry": source
}, {
"name": target_name,
"geometry": target
}],
actions=[("ICP Registration (one set)", do_icp_one_set),
("ICP Registration (two sets)", do_icp_two_sets)],
show_ui=True)
def time_animation():
orig = make_point_cloud(200, (0, 0, 0), 1.0, True)
clouds = [{"name": "t=0", "geometry": orig, "time": 0}]
drift_dir = (1.0, 0.0, 0.0)
expand = 1.0
n = 20
for i in range(1, n):
amount = float(i) / float(n - 1)
cloud = o3d.geometry.PointCloud()
pts = np.asarray(orig.points)
pts = pts * (1.0 + amount * expand) + [amount * v for v in drift_dir]
cloud.points = o3d.utility.Vector3dVector(pts)
cloud.colors = orig.colors
clouds.append({
"name": "points at t=" + str(i),
"geometry": cloud,
"time": i
})
vis.draw(clouds)
def groups():
building_mat = vis.rendering.MaterialRecord()
building_mat.shader = "defaultLit"
building_mat.base_color = (1.0, .90, .75, 1.0)
building_mat.base_reflectance = 0.1
midrise_mat = vis.rendering.MaterialRecord()
midrise_mat.shader = "defaultLit"
midrise_mat.base_color = (.475, .450, .425, 1.0)
midrise_mat.base_reflectance = 0.1
skyscraper_mat = vis.rendering.MaterialRecord()
skyscraper_mat.shader = "defaultLit"
skyscraper_mat.base_color = (.05, .20, .55, 1.0)
skyscraper_mat.base_reflectance = 0.9
skyscraper_mat.base_roughness = 0.01
buildings = []
size = 10.0
half = size / 2.0
min_height = 1.0
max_height = 20.0
for z in range(0, 10):
for x in range(0, 10):
max_h = max_height * (1.0 - abs(half - x) / half) * (
1.0 - abs(half - z) / half)
h = random.uniform(min_height, max(max_h, min_height + 1.0))
box = o3d.geometry.TriangleMesh.create_box(0.9, h, 0.9)
box.compute_triangle_normals()
box.translate((x + 0.05, 0.0, z + 0.05))
if h > 0.333 * max_height:
mat = skyscraper_mat
elif h > 0.1 * max_height:
mat = midrise_mat
else:
mat = building_mat
buildings.append({
"name": "building_" + str(x) + "_" + str(z),
"geometry": box,
"material": mat,
"group": "buildings"
})
haze = make_point_cloud(5000, (half, 0.333 * max_height, half),
1.414 * half, False)
haze.paint_uniform_color((0.8, 0.8, 0.8))
smog = make_point_cloud(10000, (half, 0.25 * max_height, half), 1.2 * half,
False)
smog.paint_uniform_color((0.95, 0.85, 0.75))
vis.draw(buildings + [{
"name": "haze",
"geometry": haze,
"group": "haze"
}, {
"name": "smog",
"geometry": smog,
"group": "smog"
}])
def remove():
def make_sphere(name, center, color, group, time):
sphere = o3d.geometry.TriangleMesh.create_sphere(0.5)
sphere.compute_vertex_normals()
sphere.translate(center)
mat = vis.rendering.Material()
mat.shader = "defaultLit"
mat.base_color = color
return {
"name": name,
"geometry": sphere,
"material": mat,
"group": group,
"time": time
}
red = make_sphere("red", (0, 0, 0), (1.0, 0.0, 0.0, 1.0), "spheres", 0)
green = make_sphere("green", (2, 0, 0), (0.0, 1.0, 0.0, 1.0), "spheres", 0)
blue = make_sphere("blue", (4, 0, 0), (0.0, 0.0, 1.0, 1.0), "spheres", 0)
yellow = make_sphere("yellow", (0, 0, 0), (1.0, 1.0, 0.0, 1.0), "spheres",
1)
bbox = {
"name": "bbox",
"geometry": red["geometry"].get_axis_aligned_bounding_box()
}
def remove_green(visdraw):
visdraw.remove_geometry("green")
def remove_yellow(visdraw):
visdraw.remove_geometry("yellow")
def remove_bbox(visdraw):
visdraw.remove_geometry("bbox")
vis.draw([red, green, blue, yellow, bbox],
actions=[("Remove Green", remove_green),
("Remove Yellow", remove_yellow),
("Remove Bounds", remove_bbox)])
def main():
single_object()
multi_objects()
actions()
selections()
if __name__ == "__main__":
main()
|
draw_webrtc.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import open3d as o3d
if __name__ == "__main__":
o3d.visualization.webrtc_server.enable_webrtc()
cube_red = o3d.geometry.TriangleMesh.create_box(1, 2, 4)
cube_red.compute_vertex_normals()
cube_red.paint_uniform_color((1.0, 0.0, 0.0))
o3d.visualization.draw(cube_red)
|
headless_rendering.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import os
import open3d as o3d
import numpy as np
import matplotlib.pyplot as plt
pyexample_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
test_data_path = os.path.join(os.path.dirname(pyexample_path), 'test_data')
def custom_draw_geometry_with_camera_trajectory(pcd):
custom_draw_geometry_with_camera_trajectory.index = -1
custom_draw_geometry_with_camera_trajectory.trajectory =\
o3d.io.read_pinhole_camera_trajectory(
os.path.join(test_data_path, 'camera_trajectory.json'))
custom_draw_geometry_with_camera_trajectory.vis = o3d.visualization.Visualizer(
)
image_path = os.path.join(test_data_path, 'image')
if not os.path.exists(image_path):
os.makedirs(image_path)
depth_path = os.path.join(test_data_path, 'depth')
if not os.path.exists(depth_path):
os.makedirs(depth_path)
def move_forward(vis):
# This function is called within the o3d.visualization.Visualizer::run() loop
# The run loop calls the function, then re-render
# So the sequence in this function is to:
# 1. Capture frame
# 2. index++, check ending criteria
# 3. Set camera
# 4. (Re-render)
ctr = vis.get_view_control()
glb = custom_draw_geometry_with_camera_trajectory
if glb.index >= 0:
print("Capture image {:05d}".format(glb.index))
depth = vis.capture_depth_float_buffer(False)
image = vis.capture_screen_float_buffer(False)
plt.imsave(os.path.join(depth_path, "{:05d}.png".format(glb.index)),\
np.asarray(depth), dpi = 1)
plt.imsave(os.path.join(image_path, "{:05d}.png".format(glb.index)),\
np.asarray(image), dpi = 1)
#vis.capture_depth_image("depth/{:05d}.png".format(glb.index), False)
#vis.capture_screen_image("image/{:05d}.png".format(glb.index), False)
glb.index = glb.index + 1
if glb.index < len(glb.trajectory.parameters):
ctr.convert_from_pinhole_camera_parameters(
glb.trajectory.parameters[glb.index])
else:
custom_draw_geometry_with_camera_trajectory.vis.\
register_animation_callback(None)
return False
vis = custom_draw_geometry_with_camera_trajectory.vis
vis.create_window()
vis.add_geometry(pcd)
vis.get_render_option().load_from_json(
os.path.join(test_data_path, 'renderoption.json'))
vis.register_animation_callback(move_forward)
vis.run()
vis.destroy_window()
if __name__ == "__main__":
if not o3d._build_config['ENABLE_HEADLESS_RENDERING']:
print("Headless rendering is not enabled. "
"Please rebuild Open3D with ENABLE_HEADLESS_RENDERING=ON")
exit(1)
sample_ply_data = o3d.data.PLYPointCloud()
pcd = o3d.io.read_point_cloud(sample_ply_data.path)
print("Customized visualization playing a camera trajectory. "
"Press ctrl+z to terminate.")
custom_draw_geometry_with_camera_trajectory(pcd)
|
interactive_visualization.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
# examples/python/visualization/interactive_visualization.py
import numpy as np
import copy
import open3d as o3d
def demo_crop_geometry():
print("Demo for manual geometry cropping")
print(
"1) Press 'Y' twice to align geometry with negative direction of y-axis"
)
print("2) Press 'K' to lock screen and to switch to selection mode")
print("3) Drag for rectangle selection,")
print(" or use ctrl + left click for polygon selection")
print("4) Press 'C' to get a selected geometry and to save it")
print("5) Press 'F' to switch to freeview mode")
pcd_data = o3d.data.DemoICPPointClouds()
pcd = o3d.io.read_point_cloud(pcd_data.paths[0])
o3d.visualization.draw_geometries_with_editing([pcd])
def draw_registration_result(source, target, transformation):
source_temp = copy.deepcopy(source)
target_temp = copy.deepcopy(target)
source_temp.paint_uniform_color([1, 0.706, 0])
target_temp.paint_uniform_color([0, 0.651, 0.929])
source_temp.transform(transformation)
o3d.visualization.draw_geometries([source_temp, target_temp])
def pick_points(pcd):
print("")
print(
"1) Please pick at least three correspondences using [shift + left click]"
)
print(" Press [shift + right click] to undo point picking")
print("2) After picking points, press 'Q' to close the window")
vis = o3d.visualization.VisualizerWithEditing()
vis.create_window()
vis.add_geometry(pcd)
vis.run() # user picks points
vis.destroy_window()
print("")
return vis.get_picked_points()
def demo_manual_registration():
print("Demo for manual ICP")
pcd_data = o3d.data.DemoICPPointClouds()
source = o3d.io.read_point_cloud(pcd_data.paths[0])
target = o3d.io.read_point_cloud(pcd_data.paths[2])
print("Visualization of two point clouds before manual alignment")
draw_registration_result(source, target, np.identity(4))
# pick points from two point clouds and builds correspondences
picked_id_source = pick_points(source)
picked_id_target = pick_points(target)
assert (len(picked_id_source) >= 3 and len(picked_id_target) >= 3)
assert (len(picked_id_source) == len(picked_id_target))
corr = np.zeros((len(picked_id_source), 2))
corr[:, 0] = picked_id_source
corr[:, 1] = picked_id_target
# estimate rough transformation using correspondences
print("Compute a rough transform using the correspondences given by user")
p2p = o3d.pipelines.registration.TransformationEstimationPointToPoint()
trans_init = p2p.compute_transformation(source, target,
o3d.utility.Vector2iVector(corr))
# point-to-point ICP for refinement
print("Perform point-to-point ICP refinement")
threshold = 0.03 # 3cm distance threshold
reg_p2p = o3d.pipelines.registration.registration_icp(
source, target, threshold, trans_init,
o3d.pipelines.registration.TransformationEstimationPointToPoint())
draw_registration_result(source, target, reg_p2p.transformation)
print("")
if __name__ == "__main__":
demo_crop_geometry()
demo_manual_registration()
|
line_width.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import open3d as o3d
import random
NUM_LINES = 10
def random_point():
return [5 * random.random(), 5 * random.random(), 5 * random.random()]
def main():
pts = [random_point() for _ in range(0, 2 * NUM_LINES)]
line_indices = [[2 * i, 2 * i + 1] for i in range(0, NUM_LINES)]
colors = [[0.0, 0.0, 0.0] for _ in range(0, NUM_LINES)]
lines = o3d.geometry.LineSet()
lines.points = o3d.utility.Vector3dVector(pts)
lines.lines = o3d.utility.Vector2iVector(line_indices)
# The default color of the lines is white, which will be invisible on the
# default white background. So we either need to set the color of the lines
# or the base_color of the material.
lines.colors = o3d.utility.Vector3dVector(colors)
# Some platforms do not require OpenGL implementations to support wide lines,
# so the renderer requires a custom shader to implement this: "unlitLine".
# The line_width field is only used by this shader; all other shaders ignore
# it.
mat = o3d.visualization.rendering.MaterialRecord()
mat.shader = "unlitLine"
mat.line_width = 10 # note that this is scaled with respect to pixels,
# so will give different results depending on the
# scaling values of your system
o3d.visualization.draw({
"name": "lines",
"geometry": lines,
"material": mat
})
if __name__ == "__main__":
main()
|
load_save_viewpoint.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import open3d as o3d
def save_view_point(pcd, filename):
vis = o3d.visualization.Visualizer()
vis.create_window()
vis.add_geometry(pcd)
vis.run() # user changes the view and press "q" to terminate
param = vis.get_view_control().convert_to_pinhole_camera_parameters()
o3d.io.write_pinhole_camera_parameters(filename, param)
vis.destroy_window()
def load_view_point(pcd, filename):
vis = o3d.visualization.Visualizer()
vis.create_window()
ctr = vis.get_view_control()
param = o3d.io.read_pinhole_camera_parameters(filename)
vis.add_geometry(pcd)
ctr.convert_from_pinhole_camera_parameters(param)
vis.run()
vis.destroy_window()
if __name__ == "__main__":
pcd_data = o3d.data.PCDPointCloud()
pcd = o3d.io.read_point_cloud(pcd_data.path)
save_view_point(pcd, "viewpoint.json")
load_view_point(pcd, "viewpoint.json")
|
mouse_and_point_coord.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import numpy as np
import open3d as o3d
import open3d.visualization.gui as gui
import open3d.visualization.rendering as rendering
# This example displays a point cloud and if you Ctrl-click on a point
# (Cmd-click on macOS) it will show the coordinates of the point.
# This example illustrates:
# - custom mouse handling on SceneWidget
# - getting a the depth value of a point (OpenGL depth)
# - converting from a window point + OpenGL depth to world coordinate
class ExampleApp:
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.MaterialRecord()
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 _on_layout(self, layout_context):
r = self.window.content_rect
self.widget3d.frame = r
pref = self.info.calc_preferred_size(layout_context,
gui.Widget.Constraints())
self.info.frame = gui.Rect(r.x,
r.get_bottom() - pref.height, pref.width,
pref.height)
def _on_mouse_widget3d(self, event):
# We could override BUTTON_DOWN without a modifier, but that would
# interfere with manipulating the scene.
if event.type == gui.MouseEvent.Type.BUTTON_DOWN and event.is_modifier_down(
gui.KeyModifier.CTRL):
def depth_callback(depth_image):
# Coordinates are expressed in absolute coordinates of the
# window, but to dereference the image correctly we need them
# relative to the origin of the widget. Note that even if the
# scene widget is the only thing in the window, if a menubar
# exists it also takes up space in the window (except on macOS).
x = event.x - self.widget3d.frame.x
y = event.y - self.widget3d.frame.y
# Note that np.asarray() reverses the axes.
depth = np.asarray(depth_image)[y, x]
if depth == 1.0: # clicked on nothing (i.e. the far plane)
text = ""
else:
world = self.widget3d.scene.camera.unproject(
event.x, event.y, depth, self.widget3d.frame.width,
self.widget3d.frame.height)
text = "({:.3f}, {:.3f}, {:.3f})".format(
world[0], world[1], world[2])
# This is not called on the main thread, so we need to
# post to the main thread to safely access UI items.
def update_label():
self.info.text = text
self.info.visible = (text != "")
# We are sizing the info label to be exactly the right size,
# so since the text likely changed width, we need to
# re-layout to set the new frame.
self.window.set_needs_layout()
gui.Application.instance.post_to_main_thread(
self.window, update_label)
self.widget3d.scene.scene.render_to_depth_image(depth_callback)
return gui.Widget.EventCallbackResult.HANDLED
return gui.Widget.EventCallbackResult.IGNORED
def main():
app = gui.Application.instance
app.initialize()
# This example will also work with a triangle mesh, or any 3D object.
# If you use a triangle mesh you will probably want to set the material
# shader to "defaultLit" instead of "defaultUnlit".
pcd_data = o3d.data.DemoICPPointClouds()
cloud = o3d.io.read_point_cloud(pcd_data.paths[0])
ex = ExampleApp(cloud)
app.run()
if __name__ == "__main__":
main()
|
multiple_windows.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import numpy as np
import open3d as o3d
import threading
import time
CLOUD_NAME = "points"
def main():
MultiWinApp().run()
class MultiWinApp:
def __init__(self):
self.is_done = False
self.n_snapshots = 0
self.cloud = None
self.main_vis = None
self.snapshot_pos = None
def run(self):
app = o3d.visualization.gui.Application.instance
app.initialize()
self.main_vis = o3d.visualization.O3DVisualizer(
"Open3D - Multi-Window Demo")
self.main_vis.add_action("Take snapshot in new window",
self.on_snapshot)
self.main_vis.set_on_close(self.on_main_window_closing)
app.add_window(self.main_vis)
self.snapshot_pos = (self.main_vis.os_frame.x, self.main_vis.os_frame.y)
threading.Thread(target=self.update_thread).start()
app.run()
def on_snapshot(self, vis):
self.n_snapshots += 1
self.snapshot_pos = (self.snapshot_pos[0] + 50,
self.snapshot_pos[1] + 50)
title = "Open3D - Multi-Window Demo (Snapshot #" + str(
self.n_snapshots) + ")"
new_vis = o3d.visualization.O3DVisualizer(title)
mat = o3d.visualization.rendering.MaterialRecord()
mat.shader = "defaultUnlit"
new_vis.add_geometry(CLOUD_NAME + " #" + str(self.n_snapshots),
self.cloud, mat)
new_vis.reset_camera_to_default()
bounds = self.cloud.get_axis_aligned_bounding_box()
extent = bounds.get_extent()
new_vis.setup_camera(60, bounds.get_center(),
bounds.get_center() + [0, 0, -3], [0, -1, 0])
o3d.visualization.gui.Application.instance.add_window(new_vis)
new_vis.os_frame = o3d.visualization.gui.Rect(self.snapshot_pos[0],
self.snapshot_pos[1],
new_vis.os_frame.width,
new_vis.os_frame.height)
def on_main_window_closing(self):
self.is_done = True
return True # False would cancel the close
def update_thread(self):
# This is NOT the UI thread, need to call post_to_main_thread() to update
# the scene or any part of the UI.
pcd_data = o3d.data.DemoICPPointClouds()
self.cloud = o3d.io.read_point_cloud(pcd_data.paths[0])
bounds = self.cloud.get_axis_aligned_bounding_box()
extent = bounds.get_extent()
def add_first_cloud():
mat = o3d.visualization.rendering.MaterialRecord()
mat.shader = "defaultUnlit"
self.main_vis.add_geometry(CLOUD_NAME, self.cloud, mat)
self.main_vis.reset_camera_to_default()
self.main_vis.setup_camera(60, bounds.get_center(),
bounds.get_center() + [0, 0, -3],
[0, -1, 0])
o3d.visualization.gui.Application.instance.post_to_main_thread(
self.main_vis, add_first_cloud)
while not self.is_done:
time.sleep(0.1)
# Perturb the cloud with a random walk to simulate an actual read
pts = np.asarray(self.cloud.points)
magnitude = 0.005 * extent
displacement = magnitude * (np.random.random_sample(pts.shape) -
0.5)
new_pts = pts + displacement
self.cloud.points = o3d.utility.Vector3dVector(new_pts)
def update_cloud():
# Note: if the number of points is less than or equal to the
# number of points in the original object that was added,
# using self.scene.update_geometry() will be faster.
# Requires that the point cloud be a t.PointCloud.
self.main_vis.remove_geometry(CLOUD_NAME)
mat = o3d.visualization.rendering.MaterialRecord()
mat.shader = "defaultUnlit"
self.main_vis.add_geometry(CLOUD_NAME, self.cloud, mat)
if self.is_done: # might have changed while sleeping
break
o3d.visualization.gui.Application.instance.post_to_main_thread(
self.main_vis, update_cloud)
if __name__ == "__main__":
main()
|
non_blocking_visualization.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
# examples/python/visualization/non_blocking_visualization.py
import open3d as o3d
import numpy as np
if __name__ == "__main__":
o3d.utility.set_verbosity_level(o3d.utility.VerbosityLevel.Debug)
pcd_data = o3d.data.DemoICPPointClouds()
source_raw = o3d.io.read_point_cloud(pcd_data.paths[0])
target_raw = o3d.io.read_point_cloud(pcd_data.paths[1])
source = source_raw.voxel_down_sample(voxel_size=0.02)
target = target_raw.voxel_down_sample(voxel_size=0.02)
trans = [[0.862, 0.011, -0.507, 0.0], [-0.139, 0.967, -0.215, 0.7],
[0.487, 0.255, 0.835, -1.4], [0.0, 0.0, 0.0, 1.0]]
source.transform(trans)
flip_transform = [[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]]
source.transform(flip_transform)
target.transform(flip_transform)
vis = o3d.visualization.Visualizer()
vis.create_window()
vis.add_geometry(source)
vis.add_geometry(target)
threshold = 0.05
icp_iteration = 100
save_image = False
for i in range(icp_iteration):
reg_p2l = o3d.pipelines.registration.registration_icp(
source, target, threshold, np.identity(4),
o3d.pipelines.registration.TransformationEstimationPointToPlane(),
o3d.pipelines.registration.ICPConvergenceCriteria(max_iteration=1))
source.transform(reg_p2l.transformation)
vis.update_geometry(source)
vis.poll_events()
vis.update_renderer()
if save_image:
vis.capture_screen_image("temp_%04d.jpg" % i)
vis.destroy_window()
o3d.utility.set_verbosity_level(o3d.utility.VerbosityLevel.Info)
|
non_english.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import open3d.visualization.gui as gui
import os.path
import platform
basedir = os.path.dirname(os.path.realpath(__file__))
# This is all-widgets.py with some modifications for non-English languages.
# Please see all-widgets.py for usage of the GUI widgets
MODE_SERIF = "serif"
MODE_COMMON_HANYU = "common"
MODE_SERIF_AND_COMMON_HANYU = "serif+common"
MODE_COMMON_HANYU_EN = "hanyu_en+common"
MODE_ALL_HANYU = "all"
MODE_CUSTOM_CHARS = "custom"
#mode = MODE_SERIF
#mode = MODE_COMMON_HANYU
mode = MODE_SERIF_AND_COMMON_HANYU
#mode = MODE_ALL_HANYU
#mode = MODE_CUSTOM_CHARS
# Fonts can be names or paths
if platform.system() == "Darwin":
serif = "Times New Roman"
hanzi = "STHeiti Light"
chess = "/System/Library/Fonts/Apple Symbols.ttf"
elif platform.system() == "Windows":
# it is necessary to specify paths on Windows since it stores its fonts
# with a cryptic name, so font name searches do not work on Windows
serif = "c:/windows/fonts/times.ttf" # Times New Roman
hanzi = "c:/windows/fonts/msyh.ttc" # YaHei UI
chess = "c:/windows/fonts/seguisym.ttf" # Segoe UI Symbol
else:
# Assumes Ubuntu 18.04
serif = "DejaVuSerif"
hanzi = "NotoSansCJK"
chess = "/usr/share/fonts/truetype/freefont/FreeSerif.ttf"
def main():
gui.Application.instance.initialize()
# Font changes must be done after initialization but before creating
# a window.
# MODE_SERIF changes the English font; Chinese will not be displayed
font = None
if mode == MODE_SERIF:
font = gui.FontDescription(serif)
# MODE_COMMON_HANYU uses the default English font and adds common Chinese
elif mode == MODE_COMMON_HANYU:
font = gui.FontDescription()
font.add_typeface_for_language(hanzi, "zh")
# MODE_SERIF_AND_COMMON_HANYU uses a serif English font and adds common
# Chinese characters
elif mode == MODE_SERIF_AND_COMMON_HANYU:
font = gui.FontDescription(serif)
font.add_typeface_for_language(hanzi, "zh")
# MODE_COMMON_HANYU_EN the Chinese font for both English and the common
# characters
elif mode == MODE_COMMON_HANYU_EN:
font = gui.FontDescription(hanzi)
font.add_typeface_for_language(hanzi, "zh")
# MODE_ALL_HANYU uses the default English font but includes all the Chinese
# characters (which uses a substantial amount of memory)
elif mode == MODE_ALL_HANYU:
font = gui.FontDescription()
font.add_typeface_for_language(hanzi, "zh_all")
elif mode == MODE_CUSTOM_CHARS:
range = [0x2654, 0x2655, 0x2656, 0x2657, 0x2658, 0x2659]
font = gui.FontDescription()
font.add_typeface_for_code_points(chess, range)
if font is not None:
gui.Application.instance.set_font(gui.Application.DEFAULT_FONT_ID, font)
w = ExampleWindow()
gui.Application.instance.run()
class ExampleWindow:
MENU_CHECKABLE = 1
MENU_DISABLED = 2
MENU_QUIT = 3
def __init__(self):
self.window = gui.Application.instance.create_window("Test", 400, 768)
# self.window = gui.Application.instance.create_window("Test", 400, 768,
# x=50, y=100)
w = self.window # for more concise code
# Rather than specifying sizes in pixels, which may vary in size based
# on the monitor, especially on macOS which has 220 dpi monitors, use
# the em-size. This way sizings will be proportional to the font size,
# which will create a more visually consistent size across platforms.
em = w.theme.font_size
# Widgets are laid out in layouts: gui.Horiz, gui.Vert,
# gui.CollapsableVert, and gui.VGrid. By nesting the layouts we can
# achieve complex designs. Usually we use a vertical layout as the
# topmost widget, since widgets tend to be organized from top to bottom.
# Within that, we usually have a series of horizontal layouts for each
# row.
layout = gui.Vert(0, gui.Margins(0.5 * em, 0.5 * em, 0.5 * em,
0.5 * em))
# Create the menu. The menu is global (because the macOS menu is global),
# so only create it once.
if gui.Application.instance.menubar is None:
menubar = gui.Menu()
test_menu = gui.Menu()
test_menu.add_item("An option", ExampleWindow.MENU_CHECKABLE)
test_menu.set_checked(ExampleWindow.MENU_CHECKABLE, True)
test_menu.add_item("Unavailable feature",
ExampleWindow.MENU_DISABLED)
test_menu.set_enabled(ExampleWindow.MENU_DISABLED, False)
test_menu.add_separator()
test_menu.add_item("Quit", ExampleWindow.MENU_QUIT)
# On macOS the first menu item is the application menu item and will
# always be the name of the application (probably "Python"),
# regardless of what you pass in here. The application menu is
# typically where About..., Preferences..., and Quit go.
menubar.add_menu("Test", test_menu)
gui.Application.instance.menubar = menubar
# Each window needs to know what to do with the menu items, so we need
# to tell the window how to handle menu items.
w.set_on_menu_item_activated(ExampleWindow.MENU_CHECKABLE,
self._on_menu_checkable)
w.set_on_menu_item_activated(ExampleWindow.MENU_QUIT,
self._on_menu_quit)
# Create a file-chooser widget. One part will be a text edit widget for
# the filename and clicking on the button will let the user choose using
# the file dialog.
self._fileedit = gui.TextEdit()
filedlgbutton = gui.Button("...")
filedlgbutton.horizontal_padding_em = 0.5
filedlgbutton.vertical_padding_em = 0
filedlgbutton.set_on_clicked(self._on_filedlg_button)
# (Create the horizontal widget for the row. This will make sure the
# text editor takes up as much space as it can.)
fileedit_layout = gui.Horiz()
fileedit_layout.add_child(gui.Label("Model file"))
fileedit_layout.add_child(self._fileedit)
fileedit_layout.add_fixed(0.25 * em)
fileedit_layout.add_child(filedlgbutton)
# add to the top-level (vertical) layout
layout.add_child(fileedit_layout)
# Create a collapsable vertical widget, which takes up enough vertical
# space for all its children when open, but only enough for text when
# closed. This is useful for property pages, so the user can hide sets
# of properties they rarely use. All layouts take a spacing parameter,
# which is the spacinging between items in the widget, and a margins
# parameter, which specifies the spacing of the left, top, right,
# bottom margins. (This acts like the 'padding' property in CSS.)
collapse = gui.CollapsableVert("Widgets", 0.33 * em,
gui.Margins(em, 0, 0, 0))
if mode == MODE_CUSTOM_CHARS:
self._label = gui.Label("♔♕♖♗♘♙")
elif mode == MODE_ALL_HANYU:
self._label = gui.Label("天地玄黃，宇宙洪荒。日月盈昃，辰宿列張。")
else:
self._label = gui.Label("锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦。")
self._label.text_color = gui.Color(1.0, 0.5, 0.0)
collapse.add_child(self._label)
# Create a checkbox. Checking or unchecking would usually be used to set
# a binary property, but in this case it will show a simple message box,
# which illustrates how to create simple dialogs.
cb = gui.Checkbox("Enable some really cool effect")
cb.set_on_checked(self._on_cb) # set the callback function
collapse.add_child(cb)
# Create a color editor. We will change the color of the orange label
# above when the color changes.
color = gui.ColorEdit()
color.color_value = self._label.text_color
color.set_on_value_changed(self._on_color)
collapse.add_child(color)
# This is a combobox, nothing fancy here, just set a simple function to
# handle the user selecting an item.
combo = gui.Combobox()
combo.add_item("Show point labels")
combo.add_item("Show point velocity")
combo.add_item("Show bounding boxes")
combo.set_on_selection_changed(self._on_combo)
collapse.add_child(combo)
# Add a simple image
logo = gui.ImageWidget(basedir + "/icon-32.png")
collapse.add_child(logo)
# Add a list of items
lv = gui.ListView()
lv.set_items(["Ground", "Trees", "Buildings" "Cars", "People"])
lv.selected_index = lv.selected_index + 2 # initially is -1, so now 1
lv.set_on_selection_changed(self._on_list)
collapse.add_child(lv)
# Add a tree view
tree = gui.TreeView()
tree.add_text_item(tree.get_root_item(), "Camera")
geo_id = tree.add_text_item(tree.get_root_item(), "Geometries")
mesh_id = tree.add_text_item(geo_id, "Mesh")
tree.add_text_item(mesh_id, "Triangles")
tree.add_text_item(mesh_id, "Albedo texture")
tree.add_text_item(mesh_id, "Normal map")
points_id = tree.add_text_item(geo_id, "Points")
tree.can_select_items_with_children = True
tree.set_on_selection_changed(self._on_tree)
# does not call on_selection_changed: user did not change selection
tree.selected_item = points_id
collapse.add_child(tree)
# Add two number editors, one for integers and one for floating point
# Number editor can clamp numbers to a range, although this is more
# useful for integers than for floating point.
intedit = gui.NumberEdit(gui.NumberEdit.INT)
intedit.int_value = 0
intedit.set_limits(1, 19) # value coerced to 1
intedit.int_value = intedit.int_value + 2 # value should be 3
doubleedit = gui.NumberEdit(gui.NumberEdit.DOUBLE)
numlayout = gui.Horiz()
numlayout.add_child(gui.Label("int"))
numlayout.add_child(intedit)
numlayout.add_fixed(em) # manual spacing (could set it in Horiz() ctor)
numlayout.add_child(gui.Label("double"))
numlayout.add_child(doubleedit)
collapse.add_child(numlayout)
# Create a progress bar. It ranges from 0.0 to 1.0.
self._progress = gui.ProgressBar()
self._progress.value = 0.25 # 25% complete
self._progress.value = self._progress.value + 0.08 # 0.25 + 0.08 = 33%
prog_layout = gui.Horiz(em)
prog_layout.add_child(gui.Label("Progress..."))
prog_layout.add_child(self._progress)
collapse.add_child(prog_layout)
# Create a slider. It acts very similar to NumberEdit except that the
# user moves a slider and cannot type the number.
slider = gui.Slider(gui.Slider.INT)
slider.set_limits(5, 13)
slider.set_on_value_changed(self._on_slider)
collapse.add_child(slider)
# Create a text editor. The placeholder text (if not empty) will be
# displayed when there is no text, as concise help, or visible tooltip.
tedit = gui.TextEdit()
tedit.placeholder_text = "Edit me some text here"
# on_text_changed fires whenever the user changes the text (but not if
# the text_value property is assigned to).
tedit.set_on_text_changed(self._on_text_changed)
# on_value_changed fires whenever the user signals that they are finished
# editing the text, either by pressing return or by clicking outside of
# the text editor, thus losing text focus.
tedit.set_on_value_changed(self._on_value_changed)
collapse.add_child(tedit)
# Create a widget for showing/editing a 3D vector
vedit = gui.VectorEdit()
vedit.vector_value = [1, 2, 3]
vedit.set_on_value_changed(self._on_vedit)
collapse.add_child(vedit)
# Create a VGrid layout. This layout specifies the number of columns
# (two, in this case), and will place the first child in the first
# column, the second in the second, the third in the first, the fourth
# in the second, etc.
# So:
# 2 cols 3 cols 4 cols
# | 1 | 2 | | 1 | 2 | 3 | | 1 | 2 | 3 | 4 |
# | 3 | 4 | | 4 | 5 | 6 | | 5 | 6 | 7 | 8 |
# | 5 | 6 | | 7 | 8 | 9 | | 9 | 10 | 11 | 12 |
# | ... | | ... | | ... |
vgrid = gui.VGrid(2)
vgrid.add_child(gui.Label("Trees"))
vgrid.add_child(gui.Label("12 items"))
vgrid.add_child(gui.Label("People"))
vgrid.add_child(gui.Label("2 (93% certainty)"))
vgrid.add_child(gui.Label("Cars"))
vgrid.add_child(gui.Label("5 (87% certainty)"))
collapse.add_child(vgrid)
# Create a tab control. This is really a set of N layouts on top of each
# other, but with only one selected.
tabs = gui.TabControl()
tab1 = gui.Vert()
tab1.add_child(gui.Checkbox("Enable option 1"))
tab1.add_child(gui.Checkbox("Enable option 2"))
tab1.add_child(gui.Checkbox("Enable option 3"))
tabs.add_tab("Options", tab1)
tab2 = gui.Vert()
tab2.add_child(gui.Label("No plugins detected"))
tab2.add_stretch()
tabs.add_tab("Plugins", tab2)
collapse.add_child(tabs)
# Quit button. (Typically this is a menu item)
button_layout = gui.Horiz()
ok_button = gui.Button("Ok")
ok_button.set_on_clicked(self._on_ok)
button_layout.add_stretch()
button_layout.add_child(ok_button)
layout.add_child(collapse)
layout.add_child(button_layout)
# We're done, set the window's layout
w.add_child(layout)
def _on_filedlg_button(self):
filedlg = gui.FileDialog(gui.FileDialog.OPEN, "Select file",
self.window.theme)
filedlg.add_filter(".obj .ply .stl", "Triangle mesh (.obj, .ply, .stl)")
filedlg.add_filter("", "All files")
filedlg.set_on_cancel(self._on_filedlg_cancel)
filedlg.set_on_done(self._on_filedlg_done)
self.window.show_dialog(filedlg)
def _on_filedlg_cancel(self):
self.window.close_dialog()
def _on_filedlg_done(self, path):
self._fileedit.text_value = path
self.window.close_dialog()
def _on_cb(self, is_checked):
if is_checked:
text = "Sorry, effects are unimplemented"
else:
text = "Good choice"
self.show_message_dialog("There might be a problem...", text)
# This function is essentially the same as window.show_message_box(),
# so for something this simple just use that, but it illustrates making a
# dialog.
def show_message_dialog(self, title, message):
# A Dialog is just a widget, so you make its child a layout just like
# a Window.
dlg = gui.Dialog(title)
# Add the message text
em = self.window.theme.font_size
dlg_layout = gui.Vert(em, gui.Margins(em, em, em, em))
dlg_layout.add_child(gui.Label(message))
# Add the Ok button. We need to define a callback function to handle
# the click.
ok_button = gui.Button("Ok")
ok_button.set_on_clicked(self._on_dialog_ok)
# We want the Ok button to be an the right side, so we need to add
# a stretch item to the layout, otherwise the button will be the size
# of the entire row. A stretch item takes up as much space as it can,
# which forces the button to be its minimum size.
button_layout = gui.Horiz()
button_layout.add_stretch()
button_layout.add_child(ok_button)
# Add the button layout,
dlg_layout.add_child(button_layout)
# ... then add the layout as the child of the Dialog
dlg.add_child(dlg_layout)
# ... and now we can show the dialog
self.window.show_dialog(dlg)
def _on_dialog_ok(self):
self.window.close_dialog()
def _on_color(self, new_color):
self._label.text_color = new_color
def _on_combo(self, new_val, new_idx):
print(new_idx, new_val)
def _on_list(self, new_val, is_dbl_click):
print(new_val)
def _on_tree(self, new_item_id):
print(new_item_id)
def _on_slider(self, new_val):
self._progress.value = new_val / 20.0
def _on_text_changed(self, new_text):
print("edit:", new_text)
def _on_value_changed(self, new_text):
print("value:", new_text)
def _on_vedit(self, new_val):
print(new_val)
def _on_ok(self):
gui.Application.instance.quit()
def _on_menu_checkable(self):
gui.Application.instance.menubar.set_checked(
ExampleWindow.MENU_CHECKABLE,
not gui.Application.instance.menubar.is_checked(
ExampleWindow.MENU_CHECKABLE))
def _on_menu_quit(self):
gui.Application.instance.quit()
# This class is essentially the same as window.show_message_box(),
# so for something this simple just use that, but it illustrates making a
# dialog.
class MessageBox:
def __init__(self, title, message):
self._window = None
# A Dialog is just a widget, so you make its child a layout just like
# a Window.
dlg = gui.Dialog(title)
# Add the message text
em = self.window.theme.font_size
dlg_layout = gui.Vert(em, gui.Margins(em, em, em, em))
dlg_layout.add_child(gui.Label(message))
# Add the Ok button. We need to define a callback function to handle
# the click.
ok_button = gui.Button("Ok")
ok_button.set_on_clicked(self._on_ok)
# We want the Ok button to be an the right side, so we need to add
# a stretch item to the layout, otherwise the button will be the size
# of the entire row. A stretch item takes up as much space as it can,
# which forces the button to be its minimum size.
button_layout = gui.Horiz()
button_layout.add_stretch()
button_layout.add_child(ok_button)
# Add the button layout,
dlg_layout.add_child(button_layout)
# ... then add the layout as the child of the Dialog
dlg.add_child(dlg_layout)
def show(self, window):
self._window = window
def _on_ok(self):
self._window.close_dialog()
if __name__ == "__main__":
main()
|
online_processing.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
"""Online 3D depth video processing pipeline.
- Connects to a RGBD camera or RGBD video file (currently
RealSense camera and bag file format are supported).
- Captures / reads color and depth frames. Allow recording from camera.
- Convert frames to point cloud, optionally with normals.
- Visualize point cloud video and results.
- Save point clouds and RGBD images for selected frames.
For this example, Open3D must be built with -DBUILD_LIBREALSENSE=ON
"""
import os
import json
import time
import logging as log
import argparse
import threading
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor
import numpy as np
import open3d as o3d
import open3d.visualization.gui as gui
import open3d.visualization.rendering as rendering
# Camera and processing
class PipelineModel:
"""Controls IO (camera, video file, recording, saving frames). Methods run
in worker threads."""
def __init__(self,
update_view,
camera_config_file=None,
rgbd_video=None,
device=None):
"""Initialize.
Args:
update_view (callback): Callback to update display elements for a
frame.
camera_config_file (str): Camera configuration json file.
rgbd_video (str): RS bag file containing the RGBD video. If this is
provided, connected cameras are ignored.
device (str): Compute device (e.g.: 'cpu:0' or 'cuda:0').
"""
self.update_view = update_view
if device:
self.device = device.lower()
else:
self.device = 'cuda:0' if o3d.core.cuda.is_available() else 'cpu:0'
self.o3d_device = o3d.core.Device(self.device)
self.video = None
self.camera = None
self.flag_capture = False
self.cv_capture = threading.Condition() # condition variable
self.recording = False # Are we currently recording
self.flag_record = False # Request to start/stop recording
if rgbd_video: # Video file
self.video = o3d.t.io.RGBDVideoReader.create(rgbd_video)
self.rgbd_metadata = self.video.metadata
self.status_message = f"Video {rgbd_video} opened."
else: # RGBD camera
now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
filename = f"{now}.bag"
self.camera = o3d.t.io.RealSenseSensor()
if camera_config_file:
with open(camera_config_file) as ccf:
self.camera.init_sensor(o3d.t.io.RealSenseSensorConfig(
json.load(ccf)),
filename=filename)
else:
self.camera.init_sensor(filename=filename)
self.camera.start_capture(start_record=False)
self.rgbd_metadata = self.camera.get_metadata()
self.status_message = f"Camera {self.rgbd_metadata.serial_number} opened."
log.info(self.rgbd_metadata)
# RGBD -> PCD
self.extrinsics = o3d.core.Tensor.eye(4,
dtype=o3d.core.Dtype.Float32,
device=self.o3d_device)
self.intrinsic_matrix = o3d.core.Tensor(
self.rgbd_metadata.intrinsics.intrinsic_matrix,
dtype=o3d.core.Dtype.Float32,
device=self.o3d_device)
self.depth_max = 3.0 # m
self.pcd_stride = 2 # downsample point cloud, may increase frame rate
self.flag_normals = False
self.flag_save_rgbd = False
self.flag_save_pcd = False
self.pcd_frame = None
self.rgbd_frame = None
self.executor = ThreadPoolExecutor(max_workers=3,
thread_name_prefix='Capture-Save')
self.flag_exit = False
@property
def max_points(self):
"""Max points in one frame for the camera or RGBD video resolution."""
return self.rgbd_metadata.width * self.rgbd_metadata.height
@property
def vfov(self):
"""Camera or RGBD video vertical field of view."""
return np.rad2deg(2 * np.arctan(self.intrinsic_matrix[1, 2].item() /
self.intrinsic_matrix[1, 1].item()))
def run(self):
"""Run pipeline."""
n_pts = 0
frame_id = 0
t1 = time.perf_counter()
if self.video:
self.rgbd_frame = self.video.next_frame()
else:
self.rgbd_frame = self.camera.capture_frame(
wait=True, align_depth_to_color=True)
pcd_errors = 0
while (not self.flag_exit and
(self.video is None or # Camera
(self.video and not self.video.is_eof()))): # Video
if self.video:
future_rgbd_frame = self.executor.submit(self.video.next_frame)
else:
future_rgbd_frame = self.executor.submit(
self.camera.capture_frame,
wait=True,
align_depth_to_color=True)
if self.flag_save_pcd:
self.save_pcd()
self.flag_save_pcd = False
try:
self.rgbd_frame = self.rgbd_frame.to(self.o3d_device)
self.pcd_frame = o3d.t.geometry.PointCloud.create_from_rgbd_image(
self.rgbd_frame, self.intrinsic_matrix, self.extrinsics,
self.rgbd_metadata.depth_scale, self.depth_max,
self.pcd_stride, self.flag_normals)
depth_in_color = self.rgbd_frame.depth.colorize_depth(
self.rgbd_metadata.depth_scale, 0, self.depth_max)
except RuntimeError:
pcd_errors += 1
if self.pcd_frame.is_empty():
log.warning(f"No valid depth data in frame {frame_id})")
continue
n_pts += self.pcd_frame.point['positions'].shape[0]
if frame_id % 60 == 0 and frame_id > 0:
t0, t1 = t1, time.perf_counter()
log.debug(f"\nframe_id = {frame_id}, \t {(t1-t0)*1000./60:0.2f}"
f"ms/frame \t {(t1-t0)*1e9/n_pts} ms/Mp\t")
n_pts = 0
frame_elements = {
'color': self.rgbd_frame.color.cpu(),
'depth': depth_in_color.cpu(),
'pcd': self.pcd_frame.cpu(),
'status_message': self.status_message
}
self.update_view(frame_elements)
if self.flag_save_rgbd:
self.save_rgbd()
self.flag_save_rgbd = False
self.rgbd_frame = future_rgbd_frame.result()
with self.cv_capture: # Wait for capture to be enabled
self.cv_capture.wait_for(
predicate=lambda: self.flag_capture or self.flag_exit)
self.toggle_record()
frame_id += 1
if self.camera:
self.camera.stop_capture()
else:
self.video.close()
self.executor.shutdown()
log.debug(f"create_from_depth_image() errors = {pcd_errors}")
def toggle_record(self):
if self.camera is not None:
if self.flag_record and not self.recording:
self.camera.resume_record()
self.recording = True
elif not self.flag_record and self.recording:
self.camera.pause_record()
self.recording = False
def save_pcd(self):
"""Save current point cloud."""
now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
filename = f"{self.rgbd_metadata.serial_number}_pcd_{now}.ply"
# Convert colors to uint8 for compatibility
self.pcd_frame.point['colors'] = (self.pcd_frame.point['colors'] *
255).to(o3d.core.Dtype.UInt8)
self.executor.submit(o3d.t.io.write_point_cloud,
filename,
self.pcd_frame,
write_ascii=False,
compressed=True,
print_progress=False)
self.status_message = f"Saving point cloud to {filename}."
def save_rgbd(self):
"""Save current RGBD image pair."""
now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
filename = f"{self.rgbd_metadata.serial_number}_color_{now}.jpg"
self.executor.submit(o3d.t.io.write_image, filename,
self.rgbd_frame.color)
filename = f"{self.rgbd_metadata.serial_number}_depth_{now}.png"
self.executor.submit(o3d.t.io.write_image, filename,
self.rgbd_frame.depth)
self.status_message = (
f"Saving RGBD images to {filename[:-3]}.{{jpg,png}}.")
class PipelineView:
"""Controls display and user interface. All methods must run in the main thread."""
def __init__(self, vfov=60, max_pcd_vertices=1 << 20, **callbacks):
"""Initialize.
Args:
vfov (float): Vertical field of view for the 3D scene.
max_pcd_vertices (int): Maximum point clud verties for which memory
is allocated.
callbacks (dict of kwargs): Callbacks provided by the controller
for various operations.
"""
self.vfov = vfov
self.max_pcd_vertices = max_pcd_vertices
gui.Application.instance.initialize()
self.window = gui.Application.instance.create_window(
"Open3D || Online RGBD Video Processing", 1280, 960)
# Called on window layout (eg: resize)
self.window.set_on_layout(self.on_layout)
self.window.set_on_close(callbacks['on_window_close'])
self.pcd_material = o3d.visualization.rendering.MaterialRecord()
self.pcd_material.shader = "defaultLit"
# Set n_pixels displayed for each 3D point, accounting for HiDPI scaling
self.pcd_material.point_size = int(4 * self.window.scaling)
# 3D scene
self.pcdview = gui.SceneWidget()
self.window.add_child(self.pcdview)
self.pcdview.enable_scene_caching(
True) # makes UI _much_ more responsive
self.pcdview.scene = rendering.Open3DScene(self.window.renderer)
self.pcdview.scene.set_background([1, 1, 1, 1]) # White background
self.pcdview.scene.set_lighting(
rendering.Open3DScene.LightingProfile.SOFT_SHADOWS, [0, -6, 0])
# Point cloud bounds, depends on the sensor range
self.pcd_bounds = o3d.geometry.AxisAlignedBoundingBox([-3, -3, 0],
[3, 3, 6])
self.camera_view() # Initially look from the camera
em = self.window.theme.font_size
# Options panel
self.panel = gui.Vert(em, gui.Margins(em, em, em, em))
self.panel.preferred_width = int(360 * self.window.scaling)
self.window.add_child(self.panel)
toggles = gui.Horiz(em)
self.panel.add_child(toggles)
toggle_capture = gui.ToggleSwitch("Capture / Play")
toggle_capture.is_on = False
toggle_capture.set_on_clicked(
callbacks['on_toggle_capture']) # callback
toggles.add_child(toggle_capture)
self.flag_normals = False
self.toggle_normals = gui.ToggleSwitch("Colors / Normals")
self.toggle_normals.is_on = False
self.toggle_normals.set_on_clicked(
callbacks['on_toggle_normals']) # callback
toggles.add_child(self.toggle_normals)
view_buttons = gui.Horiz(em)
self.panel.add_child(view_buttons)
view_buttons.add_stretch() # for centering
camera_view = gui.Button("Camera view")
camera_view.set_on_clicked(self.camera_view) # callback
view_buttons.add_child(camera_view)
birds_eye_view = gui.Button("Bird's eye view")
birds_eye_view.set_on_clicked(self.birds_eye_view) # callback
view_buttons.add_child(birds_eye_view)
view_buttons.add_stretch() # for centering
save_toggle = gui.Horiz(em)
self.panel.add_child(save_toggle)
save_toggle.add_child(gui.Label("Record / Save"))
self.toggle_record = None
if callbacks['on_toggle_record'] is not None:
save_toggle.add_fixed(1.5 * em)
self.toggle_record = gui.ToggleSwitch("Video")
self.toggle_record.is_on = False
self.toggle_record.set_on_clicked(callbacks['on_toggle_record'])
save_toggle.add_child(self.toggle_record)
save_buttons = gui.Horiz(em)
self.panel.add_child(save_buttons)
save_buttons.add_stretch() # for centering
save_pcd = gui.Button("Save Point cloud")
save_pcd.set_on_clicked(callbacks['on_save_pcd'])
save_buttons.add_child(save_pcd)
save_rgbd = gui.Button("Save RGBD frame")
save_rgbd.set_on_clicked(callbacks['on_save_rgbd'])
save_buttons.add_child(save_rgbd)
save_buttons.add_stretch() # for centering
self.video_size = (int(240 * self.window.scaling),
int(320 * self.window.scaling), 3)
self.show_color = gui.CollapsableVert("Color image")
self.show_color.set_is_open(False)
self.panel.add_child(self.show_color)
self.color_video = gui.ImageWidget(
o3d.geometry.Image(np.zeros(self.video_size, dtype=np.uint8)))
self.show_color.add_child(self.color_video)
self.show_depth = gui.CollapsableVert("Depth image")
self.show_depth.set_is_open(False)
self.panel.add_child(self.show_depth)
self.depth_video = gui.ImageWidget(
o3d.geometry.Image(np.zeros(self.video_size, dtype=np.uint8)))
self.show_depth.add_child(self.depth_video)
self.status_message = gui.Label("")
self.panel.add_child(self.status_message)
self.flag_exit = False
self.flag_gui_init = False
def update(self, frame_elements):
"""Update visualization with point cloud and images. Must run in main
thread since this makes GUI calls.
Args:
frame_elements: dict {element_type: geometry element}.
Dictionary of element types to geometry elements to be updated
in the GUI:
'pcd': point cloud,
'color': rgb image (3 channel, uint8),
'depth': depth image (uint8),
'status_message': message
"""
if not self.flag_gui_init:
# Set dummy point cloud to allocate graphics memory
dummy_pcd = o3d.t.geometry.PointCloud({
'positions':
o3d.core.Tensor.zeros((self.max_pcd_vertices, 3),
o3d.core.Dtype.Float32),
'colors':
o3d.core.Tensor.zeros((self.max_pcd_vertices, 3),
o3d.core.Dtype.Float32),
'normals':
o3d.core.Tensor.zeros((self.max_pcd_vertices, 3),
o3d.core.Dtype.Float32)
})
if self.pcdview.scene.has_geometry('pcd'):
self.pcdview.scene.remove_geometry('pcd')
self.pcd_material.shader = "normals" if self.flag_normals else "defaultLit"
self.pcdview.scene.add_geometry('pcd', dummy_pcd, self.pcd_material)
self.flag_gui_init = True
# TODO(ssheorey) Switch to update_geometry() after #3452 is fixed
if os.name == 'nt':
self.pcdview.scene.remove_geometry('pcd')
self.pcdview.scene.add_geometry('pcd', frame_elements['pcd'],
self.pcd_material)
else:
update_flags = (rendering.Scene.UPDATE_POINTS_FLAG |
rendering.Scene.UPDATE_COLORS_FLAG |
(rendering.Scene.UPDATE_NORMALS_FLAG
if self.flag_normals else 0))
self.pcdview.scene.scene.update_geometry('pcd',
frame_elements['pcd'],
update_flags)
# Update color and depth images
# TODO(ssheorey) Remove CPU transfer after we have CUDA -> OpenGL bridge
if self.show_color.get_is_open() and 'color' in frame_elements:
sampling_ratio = self.video_size[1] / frame_elements['color'].columns
self.color_video.update_image(
frame_elements['color'].resize(sampling_ratio).cpu())
if self.show_depth.get_is_open() and 'depth' in frame_elements:
sampling_ratio = self.video_size[1] / frame_elements['depth'].columns
self.depth_video.update_image(
frame_elements['depth'].resize(sampling_ratio).cpu())
if 'status_message' in frame_elements:
self.status_message.text = frame_elements["status_message"]
self.pcdview.force_redraw()
def camera_view(self):
"""Callback to reset point cloud view to the camera"""
self.pcdview.setup_camera(self.vfov, self.pcd_bounds, [0, 0, 0])
# Look at [0, 0, 1] from camera placed at [0, 0, 0] with Y axis
# pointing at [0, -1, 0]
self.pcdview.scene.camera.look_at([0, 0, 1], [0, 0, 0], [0, -1, 0])
def birds_eye_view(self):
"""Callback to reset point cloud view to birds eye (overhead) view"""
self.pcdview.setup_camera(self.vfov, self.pcd_bounds, [0, 0, 0])
self.pcdview.scene.camera.look_at([0, 0, 1.5], [0, 3, 1.5], [0, -1, 0])
def on_layout(self, layout_context):
# The on_layout callback should set the frame (position + size) of every
# child correctly. After the callback is done the window will layout
# the grandchildren.
"""Callback on window initialize / resize"""
frame = self.window.content_rect
self.pcdview.frame = frame
panel_size = self.panel.calc_preferred_size(layout_context,
self.panel.Constraints())
self.panel.frame = gui.Rect(frame.get_right() - panel_size.width,
frame.y, panel_size.width,
panel_size.height)
class PipelineController:
"""Entry point for the app. Controls the PipelineModel object for IO and
processing and the PipelineView object for display and UI. All methods
operate on the main thread.
"""
def __init__(self, camera_config_file=None, rgbd_video=None, device=None):
"""Initialize.
Args:
camera_config_file (str): Camera configuration json file.
rgbd_video (str): RS bag file containing the RGBD video. If this is
provided, connected cameras are ignored.
device (str): Compute device (e.g.: 'cpu:0' or 'cuda:0').
"""
self.pipeline_model = PipelineModel(self.update_view,
camera_config_file, rgbd_video,
device)
self.pipeline_view = PipelineView(
1.25 * self.pipeline_model.vfov,
self.pipeline_model.max_points,
on_window_close=self.on_window_close,
on_toggle_capture=self.on_toggle_capture,
on_save_pcd=self.on_save_pcd,
on_save_rgbd=self.on_save_rgbd,
on_toggle_record=self.on_toggle_record
if rgbd_video is None else None,
on_toggle_normals=self.on_toggle_normals)
threading.Thread(name='PipelineModel',
target=self.pipeline_model.run).start()
gui.Application.instance.run()
def update_view(self, frame_elements):
"""Updates view with new data. May be called from any thread.
Args:
frame_elements (dict): Display elements (point cloud and images)
from the new frame to be shown.
"""
gui.Application.instance.post_to_main_thread(
self.pipeline_view.window,
lambda: self.pipeline_view.update(frame_elements))
def on_toggle_capture(self, is_enabled):
"""Callback to toggle capture."""
self.pipeline_model.flag_capture = is_enabled
if not is_enabled:
self.on_toggle_record(False)
if self.pipeline_view.toggle_record is not None:
self.pipeline_view.toggle_record.is_on = False
else:
with self.pipeline_model.cv_capture:
self.pipeline_model.cv_capture.notify()
def on_toggle_record(self, is_enabled):
"""Callback to toggle recording RGBD video."""
self.pipeline_model.flag_record = is_enabled
def on_toggle_normals(self, is_enabled):
"""Callback to toggle display of normals"""
self.pipeline_model.flag_normals = is_enabled
self.pipeline_view.flag_normals = is_enabled
self.pipeline_view.flag_gui_init = False
def on_window_close(self):
"""Callback when the user closes the application window."""
self.pipeline_model.flag_exit = True
with self.pipeline_model.cv_capture:
self.pipeline_model.cv_capture.notify_all()
return True # OK to close window
def on_save_pcd(self):
"""Callback to save current point cloud."""
self.pipeline_model.flag_save_pcd = True
def on_save_rgbd(self):
"""Callback to save current RGBD image pair."""
self.pipeline_model.flag_save_rgbd = True
if __name__ == "__main__":
log.basicConfig(level=log.INFO)
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('--camera-config',
help='RGBD camera configuration JSON file')
parser.add_argument('--rgbd-video', help='RGBD video file (RealSense bag)')
parser.add_argument('--device',
help='Device to run computations. e.g. cpu:0 or cuda:0 '
'Default is CUDA GPU if available, else CPU.')
args = parser.parse_args()
if args.camera_config and args.rgbd_video:
log.critical(
"Please provide only one of --camera-config and --rgbd-video arguments"
)
else:
PipelineController(args.camera_config, args.rgbd_video, args.device)
|
remove_geometry.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import open3d as o3d
import numpy as np
import time
import copy
def visualize_non_blocking(vis, pcds):
for pcd in pcds:
vis.update_geometry(pcd)
vis.poll_events()
vis.update_renderer()
pcd_data = o3d.data.PCDPointCloud()
pcd_orig = o3d.io.read_point_cloud(pcd_data.path)
flip_transform = [[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]]
pcd_orig.transform(flip_transform)
n_pcd = 5
pcds = []
for i in range(n_pcd):
pcds.append(copy.deepcopy(pcd_orig))
trans = np.identity(4)
trans[:3, 3] = [3 * i, 0, 0]
pcds[i].transform(trans)
vis = o3d.visualization.Visualizer()
vis.create_window()
start_time = time.time()
added = [False] * n_pcd
curr_sec = int(time.time() - start_time)
prev_sec = curr_sec - 1
while True:
curr_sec = int(time.time() - start_time)
if curr_sec - prev_sec == 1:
prev_sec = curr_sec
for i in range(n_pcd):
if curr_sec % (n_pcd * 2) == i and not added[i]:
vis.add_geometry(pcds[i])
added[i] = True
print("Adding %d" % i)
if curr_sec % (n_pcd * 2) == (i + n_pcd) and added[i]:
vis.remove_geometry(pcds[i])
added[i] = False
print("Removing %d" % i)
visualize_non_blocking(vis, pcds)
|
render_to_image.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import open3d as o3d
import open3d.visualization.rendering as rendering
def main():
render = rendering.OffscreenRenderer(640, 480)
yellow = rendering.MaterialRecord()
yellow.base_color = [1.0, 0.75, 0.0, 1.0]
yellow.shader = "defaultLit"
green = rendering.MaterialRecord()
green.base_color = [0.0, 0.5, 0.0, 1.0]
green.shader = "defaultLit"
grey = rendering.MaterialRecord()
grey.base_color = [0.7, 0.7, 0.7, 1.0]
grey.shader = "defaultLit"
white = rendering.MaterialRecord()
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()
print("Saving image at test.png")
o3d.io.write_image("test.png", img, 9)
render.setup_camera(60.0, [0, 0, 0], [-10, 0, 0], [0, 0, 1])
img = render.render_to_image()
print("Saving image at test2.png")
o3d.io.write_image("test2.png", img, 9)
if __name__ == "__main__":
main()
|
tensorboard_pytorch.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import copy
import os
import sys
import numpy as np
import open3d as o3d
# pylint: disable-next=unused-import
from open3d.visualization.tensorboard_plugin.util import to_dict_batch
from torch.utils.tensorboard import SummaryWriter
BASE_LOGDIR = "demo_logs/pytorch/"
MODEL_DIR = os.path.join(
os.path.dirname(os.path.dirname(os.path.dirname(
os.path.realpath(__file__)))), "test_data", "monkey")
def small_scale(run_name="small_scale"):
"""Basic demo with cube and cylinder with normals and colors.
"""
logdir = os.path.join(BASE_LOGDIR, run_name)
writer = SummaryWriter(logdir)
cube = o3d.geometry.TriangleMesh.create_box(1, 2, 4, create_uv_map=True)
cube.compute_vertex_normals()
cylinder = o3d.geometry.TriangleMesh.create_cylinder(radius=1.0,
height=2.0,
resolution=20,
split=4,
create_uv_map=True)
cylinder.compute_vertex_normals()
colors = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
for step in range(3):
cube.paint_uniform_color(colors[step])
writer.add_3d('cube', to_dict_batch([cube]), step=step)
cylinder.paint_uniform_color(colors[step])
writer.add_3d('cylinder', to_dict_batch([cylinder]), step=step)
def property_reference(run_name="property_reference"):
"""Produces identical visualization to small_scale, but does not store
repeated properties of ``vertex_positions`` and ``vertex_normals``.
"""
logdir = os.path.join(BASE_LOGDIR, run_name)
writer = SummaryWriter(logdir)
cube = o3d.geometry.TriangleMesh.create_box(1, 2, 4, create_uv_map=True)
cube.compute_vertex_normals()
cylinder = o3d.geometry.TriangleMesh.create_cylinder(radius=1.0,
height=2.0,
resolution=20,
split=4,
create_uv_map=True)
cylinder.compute_vertex_normals()
colors = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
for step in range(3):
cube.paint_uniform_color(colors[step])
cube_summary = to_dict_batch([cube])
if step > 0:
cube_summary['vertex_positions'] = 0
cube_summary['vertex_normals'] = 0
writer.add_3d('cube', cube_summary, step=step)
cylinder.paint_uniform_color(colors[step])
cylinder_summary = to_dict_batch([cylinder])
if step > 0:
cylinder_summary['vertex_positions'] = 0
cylinder_summary['vertex_normals'] = 0
writer.add_3d('cylinder', cylinder_summary, step=step)
def large_scale(n_steps=16,
batch_size=1,
base_resolution=200,
run_name="large_scale"):
"""Generate a large scale summary. Geometry resolution increases linearly
with step. Each element in a batch is painted a different color.
"""
logdir = os.path.join(BASE_LOGDIR, run_name)
writer = SummaryWriter(logdir)
colors = []
for k in range(batch_size):
t = k * np.pi / batch_size
colors.append(((1 + np.sin(t)) / 2, (1 + np.cos(t)) / 2, t / np.pi))
for step in range(n_steps):
resolution = base_resolution * (step + 1)
cylinder_list = []
mobius_list = []
cylinder = o3d.geometry.TriangleMesh.create_cylinder(
radius=1.0, height=2.0, resolution=resolution, split=4)
cylinder.compute_vertex_normals()
mobius = o3d.geometry.TriangleMesh.create_mobius(
length_split=int(3.5 * resolution),
width_split=int(0.75 * resolution),
twists=1,
raidus=1,
flatness=1,
width=1,
scale=1)
mobius.compute_vertex_normals()
for b in range(batch_size):
cylinder_list.append(copy.deepcopy(cylinder))
cylinder_list[b].paint_uniform_color(colors[b])
mobius_list.append(copy.deepcopy(mobius))
mobius_list[b].paint_uniform_color(colors[b])
writer.add_3d('cylinder',
to_dict_batch(cylinder_list),
step=step,
max_outputs=batch_size)
writer.add_3d('mobius',
to_dict_batch(mobius_list),
step=step,
max_outputs=batch_size)
def with_material(model_dir=MODEL_DIR):
"""Read an obj model from a directory and write as a TensorBoard summary.
"""
model_name = os.path.basename(model_dir)
logdir = os.path.join(BASE_LOGDIR, model_name)
model_path = os.path.join(model_dir, model_name + ".obj")
model = o3d.t.geometry.TriangleMesh.from_legacy(
o3d.io.read_triangle_mesh(model_path))
summary_3d = {
"vertex_positions": model.vertex["positions"],
"vertex_normals": model.vertex["normals"],
"triangle_texture_uvs": model.triangle["texture_uvs"],
"triangle_indices": model.triangle["indices"],
"material_name": "defaultLit"
}
names_to_o3dprop = {"ao": "ambient_occlusion"}
for texture in ("albedo", "normal", "ao", "metallic", "roughness"):
texture_file = os.path.join(model_dir, texture + ".png")
if os.path.exists(texture_file):
texture = names_to_o3dprop.get(texture, texture)
summary_3d.update({
("material_texture_map_" + texture):
o3d.t.io.read_image(texture_file)
})
if texture == "metallic":
summary_3d.update(material_scalar_metallic=1.0)
writer = SummaryWriter(logdir)
writer.add_3d(model_name, summary_3d, step=0)
def demo_scene():
"""Write the demo_scene.py example showing rich PBR materials as a summary
"""
import demo_scene
demo_scene.check_for_required_assets()
geoms = demo_scene.create_scene()
writer = SummaryWriter(os.path.join(BASE_LOGDIR, 'demo_scene'))
for geom_data in geoms:
geom = geom_data["geometry"]
summary_3d = {}
for key, tensor in geom.vertex.items():
summary_3d["vertex_" + key] = tensor
for key, tensor in geom.triangle.items():
summary_3d["triangle_" + key] = tensor
if geom.has_valid_material():
summary_3d["material_name"] = geom.material.material_name
for key, value in geom.material.scalar_properties.items():
summary_3d["material_scalar_" + key] = value
for key, value in geom.material.vector_properties.items():
summary_3d["material_vector_" + key] = value
for key, value in geom.material.texture_maps.items():
summary_3d["material_texture_map_" + key] = value
writer.add_3d(geom_data["name"], summary_3d, step=0)
if __name__ == "__main__":
examples = ('small_scale', 'large_scale', 'property_reference',
'with_material', 'demo_scene')
selected = tuple(eg for eg in sys.argv[1:] if eg in examples)
if len(selected) == 0:
print(f'Usage: python {__file__} EXAMPLE...')
print(f' where EXAMPLE are from {examples}')
selected = ('property_reference', 'with_material')
for eg in selected:
locals()[eg]()
print(f"Run 'tensorboard --logdir {BASE_LOGDIR}' to visualize the 3D "
"summary.")
|
tensorboard_tensorflow.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import copy
import os
import sys
import numpy as np
import open3d as o3d
from open3d.visualization.tensorboard_plugin import summary
from open3d.visualization.tensorboard_plugin.util import to_dict_batch
import tensorflow as tf
BASE_LOGDIR = "demo_logs/tf/"
MODEL_DIR = os.path.join(
os.path.dirname(os.path.dirname(os.path.dirname(
os.path.realpath(__file__)))), "test_data", "monkey")
def small_scale(run_name="small_scale"):
"""Basic demo with cube and cylinder with normals and colors.
"""
logdir = os.path.join(BASE_LOGDIR, run_name)
writer = tf.summary.create_file_writer(logdir)
cube = o3d.geometry.TriangleMesh.create_box(1, 2, 4, create_uv_map=True)
cube.compute_vertex_normals()
cylinder = o3d.geometry.TriangleMesh.create_cylinder(radius=1.0,
height=2.0,
resolution=20,
split=4,
create_uv_map=True)
cylinder.compute_vertex_normals()
colors = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
with writer.as_default():
for step in range(3):
cube.paint_uniform_color(colors[step])
summary.add_3d('cube',
to_dict_batch([cube]),
step=step,
logdir=logdir)
cylinder.paint_uniform_color(colors[step])
summary.add_3d('cylinder',
to_dict_batch([cylinder]),
step=step,
logdir=logdir)
def property_reference(run_name="property_reference"):
"""Produces identical visualization to small_scale, but does not store
repeated properties of ``vertex_positions`` and ``vertex_normals``.
"""
logdir = os.path.join(BASE_LOGDIR, run_name)
writer = tf.summary.create_file_writer(logdir)
cube = o3d.geometry.TriangleMesh.create_box(1, 2, 4, create_uv_map=True)
cube.compute_vertex_normals()
cylinder = o3d.geometry.TriangleMesh.create_cylinder(radius=1.0,
height=2.0,
resolution=20,
split=4,
create_uv_map=True)
cylinder.compute_vertex_normals()
colors = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
with writer.as_default():
for step in range(3):
cube.paint_uniform_color(colors[step])
cube_summary = to_dict_batch([cube])
if step > 0:
cube_summary['vertex_positions'] = 0
cube_summary['vertex_normals'] = 0
summary.add_3d('cube', cube_summary, step=step, logdir=logdir)
cylinder.paint_uniform_color(colors[step])
cylinder_summary = to_dict_batch([cylinder])
if step > 0:
cylinder_summary['vertex_positions'] = 0
cylinder_summary['vertex_normals'] = 0
summary.add_3d('cylinder',
cylinder_summary,
step=step,
logdir=logdir)
def large_scale(n_steps=16,
batch_size=1,
base_resolution=200,
run_name="large_scale"):
"""Generate a large scale summary. Geometry resolution increases linearly
with step. Each element in a batch is painted a different color.
"""
logdir = os.path.join(BASE_LOGDIR, run_name)
writer = tf.summary.create_file_writer(logdir)
colors = []
for k in range(batch_size):
t = k * np.pi / batch_size
colors.append(((1 + np.sin(t)) / 2, (1 + np.cos(t)) / 2, t / np.pi))
with writer.as_default():
for step in range(n_steps):
resolution = base_resolution * (step + 1)
cylinder_list = []
mobius_list = []
cylinder = o3d.geometry.TriangleMesh.create_cylinder(
radius=1.0, height=2.0, resolution=resolution, split=4)
cylinder.compute_vertex_normals()
mobius = o3d.geometry.TriangleMesh.create_mobius(
length_split=int(3.5 * resolution),
width_split=int(0.75 * resolution),
twists=1,
raidus=1,
flatness=1,
width=1,
scale=1)
mobius.compute_vertex_normals()
for b in range(batch_size):
cylinder_list.append(copy.deepcopy(cylinder))
cylinder_list[b].paint_uniform_color(colors[b])
mobius_list.append(copy.deepcopy(mobius))
mobius_list[b].paint_uniform_color(colors[b])
summary.add_3d('cylinder',
to_dict_batch(cylinder_list),
step=step,
logdir=logdir,
max_outputs=batch_size)
summary.add_3d('mobius',
to_dict_batch(mobius_list),
step=step,
logdir=logdir,
max_outputs=batch_size)
def with_material(model_dir=MODEL_DIR):
"""Read an obj model from a directory and write as a TensorBoard summary.
"""
model_name = os.path.basename(model_dir)
logdir = os.path.join(BASE_LOGDIR, model_name)
model_path = os.path.join(model_dir, model_name + ".obj")
model = o3d.t.geometry.TriangleMesh.from_legacy(
o3d.io.read_triangle_mesh(model_path))
summary_3d = {
"vertex_positions": model.vertex["positions"],
"vertex_normals": model.vertex["normals"],
"triangle_texture_uvs": model.triangle["texture_uvs"],
"triangle_indices": model.triangle["indices"],
"material_name": "defaultLit"
}
names_to_o3dprop = {"ao": "ambient_occlusion"}
for texture in ("albedo", "normal", "ao", "metallic", "roughness"):
texture_file = os.path.join(model_dir, texture + ".png")
if os.path.exists(texture_file):
texture = names_to_o3dprop.get(texture, texture)
summary_3d.update({
("material_texture_map_" + texture):
o3d.t.io.read_image(texture_file)
})
if texture == "metallic":
summary_3d.update(material_scalar_metallic=1.0)
writer = tf.summary.create_file_writer(logdir)
with writer.as_default():
summary.add_3d(model_name, summary_3d, step=0, logdir=logdir)
def demo_scene():
"""Write the demo_scene.py example showing rich PBR materials as a summary.
"""
import demo_scene
demo_scene.check_for_required_assets()
geoms = demo_scene.create_scene()
logdir = os.path.join(BASE_LOGDIR, 'demo_scene')
writer = tf.summary.create_file_writer(logdir)
for geom_data in geoms:
geom = geom_data["geometry"]
summary_3d = {}
for key, tensor in geom.vertex.items():
summary_3d["vertex_" + key] = tensor
for key, tensor in geom.triangle.items():
summary_3d["triangle_" + key] = tensor
if geom.has_valid_material():
summary_3d["material_name"] = geom.material.material_name
for key, value in geom.material.scalar_properties.items():
summary_3d["material_scalar_" + key] = value
for key, value in geom.material.vector_properties.items():
summary_3d["material_vector_" + key] = value
for key, value in geom.material.texture_maps.items():
summary_3d["material_texture_map_" + key] = value
with writer.as_default():
summary.add_3d(geom_data["name"], summary_3d, step=0, logdir=logdir)
if __name__ == "__main__":
examples = ('small_scale', 'large_scale', 'property_reference',
'with_material', 'demo_scene')
selected = tuple(eg for eg in sys.argv[1:] if eg in examples)
if len(selected) == 0:
print(f'Usage: python {__file__} EXAMPLE...')
print(f' where EXAMPLE are from {examples}')
selected = ('property_reference', 'with_material')
for eg in selected:
locals()[eg]()
print(f"Run 'tensorboard --logdir {BASE_LOGDIR}' to visualize the 3D "
"summary.")
|
text3d.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import numpy as np
import open3d as o3d
import open3d.visualization.gui as gui
import open3d.visualization.rendering as rendering
def make_point_cloud(npts, center, radius):
pts = np.random.uniform(-radius, radius, size=[npts, 3]) + center
cloud = o3d.geometry.PointCloud()
cloud.points = o3d.utility.Vector3dVector(pts)
colors = np.random.uniform(0.0, 1.0, size=[npts, 3])
cloud.colors = o3d.utility.Vector3dVector(colors)
return cloud
def high_level():
app = gui.Application.instance
app.initialize()
points = make_point_cloud(100, (0, 0, 0), 1.0)
vis = o3d.visualization.O3DVisualizer("Open3D - 3D Text", 1024, 768)
vis.show_settings = True
vis.add_geometry("Points", points)
for idx in range(0, len(points.points)):
vis.add_3d_label(points.points[idx], "{}".format(idx))
vis.reset_camera_to_default()
app.add_window(vis)
app.run()
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.MaterialRecord()
mat.shader = "defaultUnlit"
mat.point_size = 5 * w.scaling
widget3d.scene.add_geometry("Points", points, mat)
for idx in range(0, len(points.points)):
l = widget3d.add_3d_label(points.points[idx], "{}".format(idx))
l.color = gui.Color(points.colors[idx][0], points.colors[idx][1],
points.colors[idx][2])
l.scale = np.random.uniform(0.5, 3.0)
bbox = widget3d.scene.bounding_box
widget3d.setup_camera(60.0, bbox, bbox.get_center())
w.add_child(widget3d)
app.run()
if __name__ == "__main__":
high_level()
low_level()
|
textured_mesh.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import sys
import os
import open3d as o3d
def main():
if len(sys.argv) < 2:
print("""Usage: textured-mesh.py [model directory]
This example will load [model directory].obj plus any of albedo, normal,
ao, metallic and roughness textures present. The textures should be named
albedo.png, normal.png, ao.png, metallic.png and roughness.png
respectively.""")
sys.exit()
model_dir = os.path.normpath(os.path.realpath(sys.argv[1]))
model_name = os.path.join(model_dir, os.path.basename(model_dir) + ".obj")
mesh = o3d.t.geometry.TriangleMesh.from_legacy(
o3d.io.read_triangle_mesh(model_name))
material = mesh.material
material.material_name = "defaultLit"
names_to_o3dprop = {"ao": "ambient_occlusion"}
for texture in ("albedo", "normal", "ao", "metallic", "roughness"):
texture_file = os.path.join(model_dir, texture + ".png")
if os.path.exists(texture_file):
texture = names_to_o3dprop.get(texture, texture)
material.texture_maps[texture] = o3d.t.io.read_image(texture_file)
if "metallic" in material.texture_maps:
material.scalar_properties["metallic"] = 1.0
o3d.visualization.draw(mesh, title=model_name)
if __name__ == "__main__":
main()
|
textured_model.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import sys
import os
import open3d as o3d
def main():
if len(sys.argv) < 2:
print("""Usage: texture-model.py [model directory]
This example will load [model directory].obj plus any of albedo, normal,
ao, metallic and roughness textures present.""")
sys.exit()
model_dir = sys.argv[1]
model_name = os.path.join(model_dir, os.path.basename(model_dir) + ".obj")
model = o3d.io.read_triangle_mesh(model_name)
material = o3d.visualization.rendering.MaterialRecord()
material.shader = "defaultLit"
albedo_name = os.path.join(model_dir, "albedo.png")
normal_name = os.path.join(model_dir, "normal.png")
ao_name = os.path.join(model_dir, "ao.png")
metallic_name = os.path.join(model_dir, "metallic.png")
roughness_name = os.path.join(model_dir, "roughness.png")
if os.path.exists(albedo_name):
material.albedo_img = o3d.io.read_image(albedo_name)
if os.path.exists(normal_name):
material.normal_img = o3d.io.read_image(normal_name)
if os.path.exists(ao_name):
material.ao_img = o3d.io.read_image(ao_name)
if os.path.exists(metallic_name):
material.base_metallic = 1.0
material.metallic_img = o3d.io.read_image(metallic_name)
if os.path.exists(roughness_name):
material.roughness_img = o3d.io.read_image(roughness_name)
o3d.visualization.draw([{
"name": "cube",
"geometry": model,
"material": material
}])
if __name__ == "__main__":
main()
|
video.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import numpy as np
import open3d as o3d
import open3d.visualization.gui as gui
import open3d.visualization.rendering as rendering
import time
import threading
def rescale_greyscale(img):
data = np.asarray(img)
assert (len(data.shape) == 2) # requires 1 channel image
dataFloat = data.astype(np.float64)
max_val = dataFloat.max()
# We don't currently support 16-bit images, so convert to 8-bit
dataFloat *= 255.0 / max_val
data8 = dataFloat.astype(np.uint8)
return o3d.geometry.Image(data8)
class VideoWindow:
def __init__(self):
self.rgb_images = []
rgbd_data = o3d.data.SampleRedwoodRGBDImages()
for path in rgbd_data.color_paths:
img = o3d.io.read_image(path)
self.rgb_images.append(img)
self.depth_images = []
for path in rgbd_data.depth_paths:
img = o3d.io.read_image(path)
# 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.MaterialRecord()
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 _on_layout(self, layout_context):
contentRect = self.window.content_rect
panel_width = 15 * layout_context.theme.font_size # 15 ems wide
self.widget3d.frame = gui.Rect(contentRect.x, contentRect.y,
contentRect.width - panel_width,
contentRect.height)
self.panel.frame = gui.Rect(self.widget3d.frame.get_right(),
contentRect.y, panel_width,
contentRect.height)
def _on_close(self):
self.is_done = True
return True # False would cancel the close
def _update_thread(self):
# This is NOT the UI thread, need to call post_to_main_thread() to update
# the scene or any part of the UI.
idx = 0
while not self.is_done:
time.sleep(0.100)
# Get the next frame, for instance, reading a frame from the camera.
rgb_frame = self.rgb_images[idx]
depth_frame = self.depth_images[idx]
idx += 1
if idx >= len(self.rgb_images):
idx = 0
# Update the images. This must be done on the UI thread.
def update():
self.rgb_widget.update_image(rgb_frame)
self.depth_widget.update_image(depth_frame)
self.widget3d.scene.set_background([1, 1, 1, 1], rgb_frame)
if not self.is_done:
gui.Application.instance.post_to_main_thread(
self.window, update)
def main():
app = o3d.visualization.gui.Application.instance
app.initialize()
win = VideoWindow()
app.run()
if __name__ == "__main__":
main()
|
vis_gui.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 | # ----------------------------------------------------------------------------
# - Open3D: www.open3d.org -
# ----------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2018-2021 www.open3d.org
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
# ----------------------------------------------------------------------------
import glob
import numpy as np
import open3d as o3d
import open3d.visualization.gui as gui
import open3d.visualization.rendering as rendering
import os
import platform
import sys
isMacOS = (platform.system() == "Darwin")
class Settings:
UNLIT = "defaultUnlit"
LIT = "defaultLit"
NORMALS = "normals"
DEPTH = "depth"
DEFAULT_PROFILE_NAME = "Bright day with sun at +Y [default]"
POINT_CLOUD_PROFILE_NAME = "Cloudy day (no direct sun)"
CUSTOM_PROFILE_NAME = "Custom"
LIGHTING_PROFILES = {
DEFAULT_PROFILE_NAME: {
"ibl_intensity": 45000,
"sun_intensity": 45000,
"sun_dir": [0.577, -0.577, -0.577],
# "ibl_rotation":
"use_ibl": True,
"use_sun": True,
},
"Bright day with sun at -Y": {
"ibl_intensity": 45000,
"sun_intensity": 45000,
"sun_dir": [0.577, 0.577, 0.577],
# "ibl_rotation":
"use_ibl": True,
"use_sun": True,
},
"Bright day with sun at +Z": {
"ibl_intensity": 45000,
"sun_intensity": 45000,
"sun_dir": [0.577, 0.577, -0.577],
# "ibl_rotation":
"use_ibl": True,
"use_sun": True,
},
"Less Bright day with sun at +Y": {
"ibl_intensity": 35000,
"sun_intensity": 50000,
"sun_dir": [0.577, -0.577, -0.577],
# "ibl_rotation":
"use_ibl": True,
"use_sun": True,
},
"Less Bright day with sun at -Y": {
"ibl_intensity": 35000,
"sun_intensity": 50000,
"sun_dir": [0.577, 0.577, 0.577],
# "ibl_rotation":
"use_ibl": True,
"use_sun": True,
},
"Less Bright day with sun at +Z": {
"ibl_intensity": 35000,
"sun_intensity": 50000,
"sun_dir": [0.577, 0.577, -0.577],
# "ibl_rotation":
"use_ibl": True,
"use_sun": True,
},
POINT_CLOUD_PROFILE_NAME: {
"ibl_intensity": 60000,
"sun_intensity": 50000,
"use_ibl": True,
"use_sun": False,
# "ibl_rotation":
},
}
DEFAULT_MATERIAL_NAME = "Polished ceramic [default]"
PREFAB = {
DEFAULT_MATERIAL_NAME: {
"metallic": 0.0,
"roughness": 0.7,
"reflectance": 0.5,
"clearcoat": 0.2,
"clearcoat_roughness": 0.2,
"anisotropy": 0.0
},
"Metal (rougher)": {
"metallic": 1.0,
"roughness": 0.5,
"reflectance": 0.9,
"clearcoat": 0.0,
"clearcoat_roughness": 0.0,
"anisotropy": 0.0
},
"Metal (smoother)": {
"metallic": 1.0,
"roughness": 0.3,
"reflectance": 0.9,
"clearcoat": 0.0,
"clearcoat_roughness": 0.0,
"anisotropy": 0.0
},
"Plastic": {
"metallic": 0.0,
"roughness": 0.5,
"reflectance": 0.5,
"clearcoat": 0.5,
"clearcoat_roughness": 0.2,
"anisotropy": 0.0
},
"Glazed ceramic": {
"metallic": 0.0,
"roughness": 0.5,
"reflectance": 0.9,
"clearcoat": 1.0,
"clearcoat_roughness": 0.1,
"anisotropy": 0.0
},
"Clay": {
"metallic": 0.0,
"roughness": 1.0,
"reflectance": 0.5,
"clearcoat": 0.1,
"clearcoat_roughness": 0.287,
"anisotropy": 0.0
},
}
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.MaterialRecord(),
Settings.UNLIT: rendering.MaterialRecord(),
Settings.NORMALS: rendering.MaterialRecord(),
Settings.DEPTH: rendering.MaterialRecord()
}
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 set_material(self, name):
self.material = self._materials[name]
self.apply_material = True
def apply_material_prefab(self, name):
assert (self.material.shader == Settings.LIT)
prefab = Settings.PREFAB[name]
for key, val in prefab.items():
setattr(self.material, "base_" + key, val)
def apply_lighting_profile(self, name):
profile = Settings.LIGHTING_PROFILES[name]
for key, val in profile.items():
setattr(self, key, val)
class AppWindow:
MENU_OPEN = 1
MENU_EXPORT = 2
MENU_QUIT = 3
MENU_SHOW_SETTINGS = 11
MENU_ABOUT = 21
DEFAULT_IBL = "default"
MATERIAL_NAMES = ["Lit", "Unlit", "Normals", "Depth"]
MATERIAL_SHADERS = [
Settings.LIT, Settings.UNLIT, Settings.NORMALS, Settings.DEPTH
]
def __init__(self, width, height):
self.settings = Settings()
resource_path = gui.Application.instance.resource_path
self.settings.new_ibl_name = resource_path + "/" + AppWindow.DEFAULT_IBL
self.window = gui.Application.instance.create_window(
"Open3D", width, height)
w = self.window # to make the code more concise
# 3D widget
self._scene = gui.SceneWidget()
self._scene.scene = rendering.Open3DScene(w.renderer)
self._scene.set_on_sun_direction_changed(self._on_sun_dir)
# ---- Settings panel ----
# Rather than specifying sizes in pixels, which may vary in size based
# on the monitor, especially on macOS which has 220 dpi monitors, use
# the em-size. This way sizings will be proportional to the font size,
# which will create a more visually consistent size across platforms.
em = w.theme.font_size
separation_height = int(round(0.5 * em))
# Widgets are laid out in layouts: gui.Horiz, gui.Vert,
# gui.CollapsableVert, and gui.VGrid. By nesting the layouts we can
# achieve complex designs. Usually we use a vertical layout as the
# topmost widget, since widgets tend to be organized from top to bottom.
# Within that, we usually have a series of horizontal layouts for each
# row. All layouts take a spacing parameter, which is the spacing
# between items in the widget, and a margins parameter, which specifies
# the spacing of the left, top, right, bottom margins. (This acts like
# the 'padding' property in CSS.)
self._settings_panel = gui.Vert(
0, gui.Margins(0.25 * em, 0.25 * em, 0.25 * em, 0.25 * em))
# Create a collapsable vertical widget, which takes up enough vertical
# space for all its children when open, but only enough for text when
# closed. This is useful for property pages, so the user can hide sets
# of properties they rarely use.
view_ctrls = gui.CollapsableVert("View controls", 0.25 * em,
gui.Margins(em, 0, 0, 0))
self._arcball_button = gui.Button("Arcball")
self._arcball_button.horizontal_padding_em = 0.5
self._arcball_button.vertical_padding_em = 0
self._arcball_button.set_on_clicked(self._set_mouse_mode_rotate)
self._fly_button = gui.Button("Fly")
self._fly_button.horizontal_padding_em = 0.5
self._fly_button.vertical_padding_em = 0
self._fly_button.set_on_clicked(self._set_mouse_mode_fly)
self._model_button = gui.Button("Model")
self._model_button.horizontal_padding_em = 0.5
self._model_button.vertical_padding_em = 0
self._model_button.set_on_clicked(self._set_mouse_mode_model)
self._sun_button = gui.Button("Sun")
self._sun_button.horizontal_padding_em = 0.5
self._sun_button.vertical_padding_em = 0
self._sun_button.set_on_clicked(self._set_mouse_mode_sun)
self._ibl_button = gui.Button("Environment")
self._ibl_button.horizontal_padding_em = 0.5
self._ibl_button.vertical_padding_em = 0
self._ibl_button.set_on_clicked(self._set_mouse_mode_ibl)
view_ctrls.add_child(gui.Label("Mouse controls"))
# We want two rows of buttons, so make two horizontal layouts. We also
# want the buttons centered, which we can do be putting a stretch item
# as the first and last item. Stretch items take up as much space as
# possible, and since there are two, they will each take half the extra
# space, thus centering the buttons.
h = gui.Horiz(0.25 * em) # row 1
h.add_stretch()
h.add_child(self._arcball_button)
h.add_child(self._fly_button)
h.add_child(self._model_button)
h.add_stretch()
view_ctrls.add_child(h)
h = gui.Horiz(0.25 * em) # row 2
h.add_stretch()
h.add_child(self._sun_button)
h.add_child(self._ibl_button)
h.add_stretch()
view_ctrls.add_child(h)
self._show_skybox = gui.Checkbox("Show skymap")
self._show_skybox.set_on_checked(self._on_show_skybox)
view_ctrls.add_fixed(separation_height)
view_ctrls.add_child(self._show_skybox)
self._bg_color = gui.ColorEdit()
self._bg_color.set_on_value_changed(self._on_bg_color)
grid = gui.VGrid(2, 0.25 * em)
grid.add_child(gui.Label("BG Color"))
grid.add_child(self._bg_color)
view_ctrls.add_child(grid)
self._show_axes = gui.Checkbox("Show axes")
self._show_axes.set_on_checked(self._on_show_axes)
view_ctrls.add_fixed(separation_height)
view_ctrls.add_child(self._show_axes)
self._profiles = gui.Combobox()
for name in sorted(Settings.LIGHTING_PROFILES.keys()):
self._profiles.add_item(name)
self._profiles.add_item(Settings.CUSTOM_PROFILE_NAME)
self._profiles.set_on_selection_changed(self._on_lighting_profile)
view_ctrls.add_fixed(separation_height)
view_ctrls.add_child(gui.Label("Lighting profiles"))
view_ctrls.add_child(self._profiles)
self._settings_panel.add_fixed(separation_height)
self._settings_panel.add_child(view_ctrls)
advanced = gui.CollapsableVert("Advanced lighting", 0,
gui.Margins(em, 0, 0, 0))
advanced.set_is_open(False)
self._use_ibl = gui.Checkbox("HDR map")
self._use_ibl.set_on_checked(self._on_use_ibl)
self._use_sun = gui.Checkbox("Sun")
self._use_sun.set_on_checked(self._on_use_sun)
advanced.add_child(gui.Label("Light sources"))
h = gui.Horiz(em)
h.add_child(self._use_ibl)
h.add_child(self._use_sun)
advanced.add_child(h)
self._ibl_map = gui.Combobox()
for ibl in glob.glob(gui.Application.instance.resource_path +
"/*_ibl.ktx"):
self._ibl_map.add_item(os.path.basename(ibl[:-8]))
self._ibl_map.selected_text = AppWindow.DEFAULT_IBL
self._ibl_map.set_on_selection_changed(self._on_new_ibl)
self._ibl_intensity = gui.Slider(gui.Slider.INT)
self._ibl_intensity.set_limits(0, 200000)
self._ibl_intensity.set_on_value_changed(self._on_ibl_intensity)
grid = gui.VGrid(2, 0.25 * em)
grid.add_child(gui.Label("HDR map"))
grid.add_child(self._ibl_map)
grid.add_child(gui.Label("Intensity"))
grid.add_child(self._ibl_intensity)
advanced.add_fixed(separation_height)
advanced.add_child(gui.Label("Environment"))
advanced.add_child(grid)
self._sun_intensity = gui.Slider(gui.Slider.INT)
self._sun_intensity.set_limits(0, 200000)
self._sun_intensity.set_on_value_changed(self._on_sun_intensity)
self._sun_dir = gui.VectorEdit()
self._sun_dir.set_on_value_changed(self._on_sun_dir)
self._sun_color = gui.ColorEdit()
self._sun_color.set_on_value_changed(self._on_sun_color)
grid = gui.VGrid(2, 0.25 * em)
grid.add_child(gui.Label("Intensity"))
grid.add_child(self._sun_intensity)
grid.add_child(gui.Label("Direction"))
grid.add_child(self._sun_dir)
grid.add_child(gui.Label("Color"))
grid.add_child(self._sun_color)
advanced.add_fixed(separation_height)
advanced.add_child(gui.Label("Sun (Directional light)"))
advanced.add_child(grid)
self._settings_panel.add_fixed(separation_height)
self._settings_panel.add_child(advanced)
material_settings = gui.CollapsableVert("Material settings", 0,
gui.Margins(em, 0, 0, 0))
self._shader = gui.Combobox()
self._shader.add_item(AppWindow.MATERIAL_NAMES[0])
self._shader.add_item(AppWindow.MATERIAL_NAMES[1])
self._shader.add_item(AppWindow.MATERIAL_NAMES[2])
self._shader.add_item(AppWindow.MATERIAL_NAMES[3])
self._shader.set_on_selection_changed(self._on_shader)
self._material_prefab = gui.Combobox()
for prefab_name in sorted(Settings.PREFAB.keys()):
self._material_prefab.add_item(prefab_name)
self._material_prefab.selected_text = Settings.DEFAULT_MATERIAL_NAME
self._material_prefab.set_on_selection_changed(self._on_material_prefab)
self._material_color = gui.ColorEdit()
self._material_color.set_on_value_changed(self._on_material_color)
self._point_size = gui.Slider(gui.Slider.INT)
self._point_size.set_limits(1, 10)
self._point_size.set_on_value_changed(self._on_point_size)
grid = gui.VGrid(2, 0.25 * em)
grid.add_child(gui.Label("Type"))
grid.add_child(self._shader)
grid.add_child(gui.Label("Material"))
grid.add_child(self._material_prefab)
grid.add_child(gui.Label("Color"))
grid.add_child(self._material_color)
grid.add_child(gui.Label("Point size"))
grid.add_child(self._point_size)
material_settings.add_child(grid)
self._settings_panel.add_fixed(separation_height)
self._settings_panel.add_child(material_settings)
# ----
# Normally our user interface can be children of all one layout (usually
# a vertical layout), which is then the only child of the window. In our
# case we want the scene to take up all the space and the settings panel
# to go above it. We can do this custom layout by providing an on_layout
# callback. The on_layout callback should set the frame
# (position + size) of every child correctly. After the callback is
# done the window will layout the grandchildren.
w.set_on_layout(self._on_layout)
w.add_child(self._scene)
w.add_child(self._settings_panel)
# ---- Menu ----
# The menu is global (because the macOS menu is global), so only create
# it once, no matter how many windows are created
if gui.Application.instance.menubar is None:
if isMacOS:
app_menu = gui.Menu()
app_menu.add_item("About", AppWindow.MENU_ABOUT)
app_menu.add_separator()
app_menu.add_item("Quit", AppWindow.MENU_QUIT)
file_menu = gui.Menu()
file_menu.add_item("Open...", AppWindow.MENU_OPEN)
file_menu.add_item("Export Current Image...", AppWindow.MENU_EXPORT)
if not isMacOS:
file_menu.add_separator()
file_menu.add_item("Quit", AppWindow.MENU_QUIT)
settings_menu = gui.Menu()
settings_menu.add_item("Lighting & Materials",
AppWindow.MENU_SHOW_SETTINGS)
settings_menu.set_checked(AppWindow.MENU_SHOW_SETTINGS, True)
help_menu = gui.Menu()
help_menu.add_item("About", AppWindow.MENU_ABOUT)
menu = gui.Menu()
if isMacOS:
# macOS will name the first menu item for the running application
# (in our case, probably "Python"), regardless of what we call
# it. This is the application menu, and it is where the
# About..., Preferences..., and Quit menu items typically go.
menu.add_menu("Example", app_menu)
menu.add_menu("File", file_menu)
menu.add_menu("Settings", settings_menu)
# Don't include help menu unless it has something more than
# About...
else:
menu.add_menu("File", file_menu)
menu.add_menu("Settings", settings_menu)
menu.add_menu("Help", help_menu)
gui.Application.instance.menubar = menu
# The menubar is global, but we need to connect the menu items to the
# window, so that the window can call the appropriate function when the
# menu item is activated.
w.set_on_menu_item_activated(AppWindow.MENU_OPEN, self._on_menu_open)
w.set_on_menu_item_activated(AppWindow.MENU_EXPORT,
self._on_menu_export)
w.set_on_menu_item_activated(AppWindow.MENU_QUIT, self._on_menu_quit)
w.set_on_menu_item_activated(AppWindow.MENU_SHOW_SETTINGS,
self._on_menu_toggle_settings_panel)
w.set_on_menu_item_activated(AppWindow.MENU_ABOUT, self._on_menu_about)
# ----
self._apply_settings()
def _apply_settings(self):
bg_color = [
self.settings.bg_color.red, self.settings.bg_color.green,
self.settings.bg_color.blue, self.settings.bg_color.alpha
]
self._scene.scene.set_background(bg_color)
self._scene.scene.show_skybox(self.settings.show_skybox)
self._scene.scene.show_axes(self.settings.show_axes)
if self.settings.new_ibl_name is not None:
self._scene.scene.scene.set_indirect_light(
self.settings.new_ibl_name)
# Clear new_ibl_name, so we don't keep reloading this image every
# time the settings are applied.
self.settings.new_ibl_name = None
self._scene.scene.scene.enable_indirect_light(self.settings.use_ibl)
self._scene.scene.scene.set_indirect_light_intensity(
self.settings.ibl_intensity)
sun_color = [
self.settings.sun_color.red, self.settings.sun_color.green,
self.settings.sun_color.blue
]
self._scene.scene.scene.set_sun_light(self.settings.sun_dir, sun_color,
self.settings.sun_intensity)
self._scene.scene.scene.enable_sun_light(self.settings.use_sun)
if self.settings.apply_material:
self._scene.scene.update_material(self.settings.material)
self.settings.apply_material = False
self._bg_color.color_value = self.settings.bg_color
self._show_skybox.checked = self.settings.show_skybox
self._show_axes.checked = self.settings.show_axes
self._use_ibl.checked = self.settings.use_ibl
self._use_sun.checked = self.settings.use_sun
self._ibl_intensity.int_value = self.settings.ibl_intensity
self._sun_intensity.int_value = self.settings.sun_intensity
self._sun_dir.vector_value = self.settings.sun_dir
self._sun_color.color_value = self.settings.sun_color
self._material_prefab.enabled = (
self.settings.material.shader == Settings.LIT)
c = gui.Color(self.settings.material.base_color[0],
self.settings.material.base_color[1],
self.settings.material.base_color[2],
self.settings.material.base_color[3])
self._material_color.color_value = c
self._point_size.double_value = self.settings.material.point_size
def _on_layout(self, layout_context):
# The on_layout callback should set the frame (position + size) of every
# child correctly. After the callback is done the window will layout
# the grandchildren.
r = self.window.content_rect
self._scene.frame = r
width = 17 * layout_context.theme.font_size
height = min(
r.height,
self._settings_panel.calc_preferred_size(
layout_context, gui.Widget.Constraints()).height)
self._settings_panel.frame = gui.Rect(r.get_right() - width, r.y, width,
height)
def _set_mouse_mode_rotate(self):
self._scene.set_view_controls(gui.SceneWidget.Controls.ROTATE_CAMERA)
def _set_mouse_mode_fly(self):
self._scene.set_view_controls(gui.SceneWidget.Controls.FLY)
def _set_mouse_mode_sun(self):
self._scene.set_view_controls(gui.SceneWidget.Controls.ROTATE_SUN)
def _set_mouse_mode_ibl(self):
self._scene.set_view_controls(gui.SceneWidget.Controls.ROTATE_IBL)
def _set_mouse_mode_model(self):
self._scene.set_view_controls(gui.SceneWidget.Controls.ROTATE_MODEL)
def _on_bg_color(self, new_color):
self.settings.bg_color = new_color
self._apply_settings()
def _on_show_skybox(self, show):
self.settings.show_skybox = show
self._apply_settings()
def _on_show_axes(self, show):
self.settings.show_axes = show
self._apply_settings()
def _on_use_ibl(self, use):
self.settings.use_ibl = use
self._profiles.selected_text = Settings.CUSTOM_PROFILE_NAME
self._apply_settings()
def _on_use_sun(self, use):
self.settings.use_sun = use
self._profiles.selected_text = Settings.CUSTOM_PROFILE_NAME
self._apply_settings()
def _on_lighting_profile(self, name, index):
if name != Settings.CUSTOM_PROFILE_NAME:
self.settings.apply_lighting_profile(name)
self._apply_settings()
def _on_new_ibl(self, name, index):
self.settings.new_ibl_name = gui.Application.instance.resource_path + "/" + name
self._profiles.selected_text = Settings.CUSTOM_PROFILE_NAME
self._apply_settings()
def _on_ibl_intensity(self, intensity):
self.settings.ibl_intensity = int(intensity)
self._profiles.selected_text = Settings.CUSTOM_PROFILE_NAME
self._apply_settings()
def _on_sun_intensity(self, intensity):
self.settings.sun_intensity = int(intensity)
self._profiles.selected_text = Settings.CUSTOM_PROFILE_NAME
self._apply_settings()
def _on_sun_dir(self, sun_dir):
self.settings.sun_dir = sun_dir
self._profiles.selected_text = Settings.CUSTOM_PROFILE_NAME
self._apply_settings()
def _on_sun_color(self, color):
self.settings.sun_color = color
self._apply_settings()
def _on_shader(self, name, index):
self.settings.set_material(AppWindow.MATERIAL_SHADERS[index])
self._apply_settings()
def _on_material_prefab(self, name, index):
self.settings.apply_material_prefab(name)
self.settings.apply_material = True
self._apply_settings()
def _on_material_color(self, color):
self.settings.material.base_color = [
color.red, color.green, color.blue, color.alpha
]
self.settings.apply_material = True
self._apply_settings()
def _on_point_size(self, size):
self.settings.material.point_size = int(size)
self.settings.apply_material = True
self._apply_settings()
def _on_menu_open(self):
dlg = gui.FileDialog(gui.FileDialog.OPEN, "Choose file to load",
self.window.theme)
dlg.add_filter(
".ply .stl .fbx .obj .off .gltf .glb",
"Triangle mesh files (.ply, .stl, .fbx, .obj, .off, "
".gltf, .glb)")
dlg.add_filter(
".xyz .xyzn .xyzrgb .ply .pcd .pts",
"Point cloud files (.xyz, .xyzn, .xyzrgb, .ply, "
".pcd, .pts)")
dlg.add_filter(".ply", "Polygon files (.ply)")
dlg.add_filter(".stl", "Stereolithography files (.stl)")
dlg.add_filter(".fbx", "Autodesk Filmbox files (.fbx)")
dlg.add_filter(".obj", "Wavefront OBJ files (.obj)")
dlg.add_filter(".off", "Object file format (.off)")
dlg.add_filter(".gltf", "OpenGL transfer files (.gltf)")
dlg.add_filter(".glb", "OpenGL binary transfer files (.glb)")
dlg.add_filter(".xyz", "ASCII point cloud files (.xyz)")
dlg.add_filter(".xyzn", "ASCII point cloud with normals (.xyzn)")
dlg.add_filter(".xyzrgb",
"ASCII point cloud files with colors (.xyzrgb)")
dlg.add_filter(".pcd", "Point Cloud Data files (.pcd)")
dlg.add_filter(".pts", "3D Points files (.pts)")
dlg.add_filter("", "All files")
# A file dialog MUST define on_cancel and on_done functions
dlg.set_on_cancel(self._on_file_dialog_cancel)
dlg.set_on_done(self._on_load_dialog_done)
self.window.show_dialog(dlg)
def _on_file_dialog_cancel(self):
self.window.close_dialog()
def _on_load_dialog_done(self, filename):
self.window.close_dialog()
self.load(filename)
def _on_menu_export(self):
dlg = gui.FileDialog(gui.FileDialog.SAVE, "Choose file to save",
self.window.theme)
dlg.add_filter(".png", "PNG files (.png)")
dlg.set_on_cancel(self._on_file_dialog_cancel)
dlg.set_on_done(self._on_export_dialog_done)
self.window.show_dialog(dlg)
def _on_export_dialog_done(self, filename):
self.window.close_dialog()
frame = self._scene.frame
self.export_image(filename, frame.width, frame.height)
def _on_menu_quit(self):
gui.Application.instance.quit()
def _on_menu_toggle_settings_panel(self):
self._settings_panel.visible = not self._settings_panel.visible
gui.Application.instance.menubar.set_checked(
AppWindow.MENU_SHOW_SETTINGS, self._settings_panel.visible)
def _on_menu_about(self):
# Show a simple dialog. Although the Dialog is actually a widget, you can
# treat it similar to a Window for layout and put all the widgets in a
# layout which you make the only child of the Dialog.
em = self.window.theme.font_size
dlg = gui.Dialog("About")
# Add the text
dlg_layout = gui.Vert(em, gui.Margins(em, em, em, em))
dlg_layout.add_child(gui.Label("Open3D GUI Example"))
# Add the Ok button. We need to define a callback function to handle
# the click.
ok = gui.Button("OK")
ok.set_on_clicked(self._on_about_ok)
# We want the Ok button to be an the right side, so we need to add
# a stretch item to the layout, otherwise the button will be the size
# of the entire row. A stretch item takes up as much space as it can,
# which forces the button to be its minimum size.
h = gui.Horiz()
h.add_stretch()
h.add_child(ok)
h.add_stretch()
dlg_layout.add_child(h)
dlg.add_child(dlg_layout)
self.window.show_dialog(dlg)
def _on_about_ok(self):
self.window.close_dialog()
def load(self, path):
self._scene.scene.clear_geometry()
geometry = None
geometry_type = o3d.io.read_file_geometry_type(path)
mesh = None
if geometry_type & o3d.io.CONTAINS_TRIANGLES:
mesh = o3d.io.read_triangle_mesh(path)
if mesh is not None:
if len(mesh.triangles) == 0:
print(
"[WARNING] Contains 0 triangles, will read as point cloud")
mesh = None
else:
mesh.compute_vertex_normals()
if len(mesh.vertex_colors) == 0:
mesh.paint_uniform_color([1, 1, 1])
geometry = mesh
# Make sure the mesh has texture coordinates
if not mesh.has_triangle_uvs():
uv = np.array([[0.0, 0.0]] * (3 * len(mesh.triangles)))
mesh.triangle_uvs = o3d.utility.Vector2dVector(uv)
else:
print("[Info]", path, "appears to be a point cloud")
if geometry is None:
cloud = None
try:
cloud = o3d.io.read_point_cloud(path)
except Exception:
pass
if cloud is not None:
print("[Info] Successfully read", path)
if not cloud.has_normals():
cloud.estimate_normals()
cloud.normalize_normals()
geometry = cloud
else:
print("[WARNING] Failed to read points", path)
if geometry is not None:
try:
self._scene.scene.add_geometry("__model__", geometry,
self.settings.material)
bounds = geometry.get_axis_aligned_bounding_box()
self._scene.setup_camera(60, bounds, bounds.get_center())
except Exception as e:
print(e)
def export_image(self, path, width, height):
def on_image(image):
img = image
quality = 9 # png
if path.endswith(".jpg"):
quality = 100
o3d.io.write_image(path, img, quality)
self._scene.scene.scene.render_to_image(on_image)
def main():
# We need to initalize the application, which finds the necessary shaders
# for rendering and prepares the cross-platform window abstraction.
gui.Application.instance.initialize()
w = AppWindow(1024, 768)
if len(sys.argv) > 1:
path = sys.argv[1]
if os.path.exists(path):
w.load(path)
else:
w.window.show_message_box("Error",
"Could not open file '" + path + "'")
# Run the event loop. This will not return until the last window is closed.
gui.Application.instance.run()
if __name__ == "__main__":
main()
|