Example o3d.visualization.gui.Application with dynamic point cloud

[alanoursland]

I'm trying to write a simple visualization gui Application with a dynamic point cloud using a custom material. I actually need two clouds with different materials. I couldn't figure out how to get different materials using o3d.visualization.Visualizer so I fell back to o3d.visualization.gui.Application and SceneWidget.

I can't figure out how to make the display update after I've changed the point cloud. My code is below with several attempts commented out.

The closest I've gotten is "widget.scene.scene.update_geometry("Geometry", geom_pcd, o3d.visualization.rendering.Scene.UPDATE_POINTS_FLAG)" but that requires a tensor point cloud instead of a o3d.geometry.PointCloud.

Also, am I right that I need to write my own run loop if I want custom behavior? Visualizer has callbacks, but I don't think the application does.

This is the code for the example:

  import open3d as o3d
  import numpy as np
  
  def generate_point_cloud():
      new_pcd = o3d.geometry.PointCloud()
      points = np.random.rand(100, 3)
      new_pcd.points = o3d.utility.Vector3dVector(points)
      return new_pcd
  
  def update_point_cloud(window, widget, geom_pcd):
      index_to_replace = np.random.randint(0, 100)
      rand_pt = np.random.rand(1, 3)
      geom_pcd.points[index_to_replace] = rand_pt[0]
      #widget.scene.update_geometry(geom_pcd)
      print("update_point_cloud")
      #widget.scene.update_geometry(geom_pcd)
      #widget.scene.update_renderer()
      #widget.scene.update()
      #widget.force_redraw()
      #geom_pcd = o3d.cpu.pybind.t.geometry.PointCloud.create_from_point_cloud(geom_pcd)
      #widget.scene.scene.update_geometry("Geometry", geom_pcd, o3d.visualization.rendering.Scene.UPDATE_POINTS_FLAG)
      #widget.scene.scene.update_geometry(geom_pcd)
      return True
  
  def main():
      app = o3d.visualization.gui.Application.instance
      app.initialize()
  
      window = app.create_window("Open3D Python App", width=800, height=600, x=0, y=30)
  
      widget = o3d.visualization.gui.SceneWidget()
      widget.scene = o3d.visualization.rendering.Open3DScene(window.renderer)
      widget.scene.set_background([1.0, 1.0, 1.0, 1.0])
      window.add_child(widget)
  
      geom_pcd = generate_point_cloud()
      geom_pcd.colors = o3d.utility.Vector3dVector(np.zeros_like(geom_pcd.points))
  
      geom_mat = o3d.visualization.rendering.MaterialRecord()
      geom_mat.shader = 'defaultUnlit'
      geom_mat.point_size = 2.0
  
      widget.scene.add_geometry("Geometry", geom_pcd, geom_mat)
  
      widget.setup_camera(60, widget.scene.bounding_box, [0, 0, 0])
  
      while app.run_one_tick():
          update_point_cloud(window, widget, geom_pcd)
          #app.post_to_main_thread(window, update_geometry)
          #app.update()
  
  if __name__ == '__main__':
      print("Open3D version:", o3d.__version__)
      main()
      

[alanoursland]

I ended up with this. If you have any other suggestions for improvements, I'd like to hear them. I'm not crazy about removing and adding the geometry to update.

import open3d as o3d
import numpy as np
import threading
import time

class DynamicPointCloudApp:
    GEOM_NAME = "Geometry"

    def __init__(self, update_delay = -1):
        self.update_delay = update_delay
        self.is_done = False
        self.lock = threading.Lock()

        self.app = o3d.visualization.gui.Application.instance
        self.window = self.app.create_window("Open3D Python App", width=800, height=600, x=0, y=30)
        self.window.set_on_close(self.on_main_window_closing)
        if self.update_delay < 0:
            self.window.set_on_tick_event(self.on_main_window_tick_event)

        self.widget = o3d.visualization.gui.SceneWidget()
        self.widget.scene = o3d.visualization.rendering.Open3DScene(self.window.renderer)
        self.widget.scene.set_background([1.0, 1.0, 1.0, 1.0])
        self.window.add_child(self.widget)

        self.geom_pcd = DynamicPointCloudApp.generate_point_cloud()
        self.geom_pcd.colors = o3d.utility.Vector3dVector(np.zeros_like(self.geom_pcd.points))

        self.geom_mat = o3d.visualization.rendering.MaterialRecord()
        self.geom_mat.shader = 'defaultUnlit'
        self.geom_mat.point_size = 2.0

        self.widget.scene.add_geometry(self.GEOM_NAME, self.geom_pcd, self.geom_mat)

        self.widget.setup_camera(60, self.widget.scene.bounding_box, [0, 0, 0])

    def generate_point_cloud():
        new_pcd = o3d.geometry.PointCloud()
        points = np.random.rand(100, 3)
        new_pcd.points = o3d.utility.Vector3dVector(points)
        return new_pcd

    def update_point_cloud(self):
        index_to_replace = np.random.randint(0, 100)
        rand_pt = np.random.rand(1, 3)
        self.geom_pcd.points[index_to_replace] = rand_pt[0]
        self.widget.enable_scene_caching(False)
        self.widget.scene.remove_geometry(self.GEOM_NAME)
        self.widget.scene.add_geometry(self.GEOM_NAME, self.geom_pcd, self.geom_mat)
        return True

    def startThread(self):
        if self.update_delay >= 0:
            threading.Thread(target=self.update_thread).start()

    def update_thread(self):
        def do_update():
            return self.update_point_cloud()

        while not self.is_done:
            time.sleep(self.update_delay)
            print("update_thread")
            with self.lock:
                if self.is_done:  # might have changed while sleeping.
                    break
                o3d.visualization.gui.Application.instance.post_to_main_thread(self.window, self.update_point_cloud)
    
    def on_main_window_closing(self):
        with self.lock:
            self.is_done = True
        return True  # False would cancel the close
    
    def on_main_window_tick_event(self):
        print("tick")
        return self.update_point_cloud()

def main():
    o3d.visualization.gui.Application.instance.initialize()

    thread_delay = 0.1
    use_tick = -1

    dpcApp = DynamicPointCloudApp(use_tick)
    dpcApp.startThread()
    
    o3d.visualization.gui.Application.instance.run()

if __name__ == '__main__':
    print("Open3D version:", o3d.__version__)
    main()