Embedding Open3D in PySide or PyQt Application

[notaTeapot]

For a project of mine, I want to embed an o3d visualization into an existing python Qt application. I found this Stackoverflow page (https://stackoverflow.com/questions/58816766/how-to-embed-a-pptk-viewer-in-a-pyqt5-window) on how to integrate a pptk window into a pyqt5 app using the win32gui package. I adapted the code with Open3D and got it running inside a widget:

The code is pretty simple and you can interact with the scene just like with the standalone window:

from PySide2 import QtWidgets, QtGui,QtCore
import open3d as o3d
import win32gui
import sys

class MainWindow(QtWidgets.QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        widget = QtWidgets.QWidget()
        layout = QtWidgets.QGridLayout(widget)
        self.setCentralWidget(widget)

        pcd = o3d.io.read_point_cloud("example.pcd")
        self.vis = o3d.visualization.Visualizer()
        self.vis.create_window()
        self.vis.add_geometry(pcd)

        hwnd = win32gui.FindWindowEx(0, 0, None, "Open3D")
        self.window = QtGui.QWindow.fromWinId(hwnd)    
        self.windowcontainer = self.createWindowContainer(self.window, widget)
        layout.addWidget(self.windowcontainer, 0, 0)
        timer = QtCore.QTimer(self)
        timer.timeout.connect(self.update_vis)
        timer.start(1)

    def update_vis(self):
        #self.vis.update_geometry()
        self.vis.poll_events()
        self.vis.update_renderer()

if __name__ == '__main__':

    app = QtWidgets.QApplication(sys.argv)
    form = MainWindow()
    form.setWindowTitle('o3d Embed')
    form.setGeometry(100, 100, 600, 500)
    form.show()
    sys.exit(app.exec_())

[ssheorey]

Nice!

[JLUJYP]

I want to implement interaction of window, be about to change self.vis = o3d.visualization.Visualizer() to self.vis = o3d.visualization.VisualizerWithEditing() , but I didn't succeed, Do you know how to solve it, thank you very much!

[hustCYQ]

I found that many times after clicking other buttons of qt, the focus is not on vis. At this time, the keyboard input does not seem to be accepted by vis. How can I solve this problem?

[hustCYQ]

https://gist.github.com/notaTeapot/5feea53dccc921ea6af88a4d222e1e2b

I found that many times after clicking other buttons of qt, the focus is not on vis. At this time, the keyboard input does not seem to be accepted by vis. How can I solve this problem?

[elevenjiang1]

Not sure whether you can solve the problem about using o3d.visualization.VisualizerWithEditing()
I can not use @wpyq code, maybe it is because open3d will segment fault when selecting point with poll_events() and update_renderer().

Here is my code for just selecting points and embedding open3d into pyqt, in Ubuntu. So I also not use win32gui but use subprocess and 'wmctrl -l'. If you want to use it, please apt install wmctrl first.

import sys
import open3d as o3d
from PyQt5.QtWidgets import QApplication,QMainWindow,QWidget,QGridLayout

from PyQt5.QtGui import QWindow
from PyQt5.QtCore import QTimer,pyqtSignal

import example_ui
from subprocess import Popen, PIPE
from threading import Thread

class MainWindow(QMainWindow):
    begin_select_point_signal=pyqtSignal()
    def __init__(self,parent=None):
        super(MainWindow, self).__init__(parent)
        self.ui = example_ui.Ui_MainWindow()
        self.ui.setupUi(self)
        
        #1: Enable button
        self.ui.pushButton_helloworld.clicked.connect(self.helloworld_button_cb)
        self.ui.pushButton_show_points.clicked.connect(self.select_points_cb)
        
        #2: Start a Timer to update points
        self.o3d_selectpoint_vis_timer=QTimer(self)
        self.o3d_selectpoint_vis_timer.timeout.connect(self.vis_run_cb)
        
    
    def get_hwnd(self):
        hwnd = None
        while hwnd == None:
            proc = Popen('wmctrl -l', stdin=None, stdout=PIPE, stderr=None, shell=True)
            out, err = proc.communicate()
            for window in out.decode('utf-8').split('\n'):
                if 'Open3D' in window:
                    hwnd = int(window.split(' ')[0], 16)
                    print("Find hwnd is:",hwnd)
                    return hwnd    

    def helloworld_button_cb(self):
        print("You press Hello World")

    def select_points_cb(self):
        pcd = o3d.io.read_point_cloud("/home/elevenjiang/Documents/Project/VisionGuidance-Project/VisionGuidance/vision/data/Objects/wall.ply")
        
        #Must use no vis mode to embed into pyqt, but get win handle with vis mode first
        self.vis = o3d.visualization.VisualizerWithEditing()
        self.vis.create_window(visible=True)
        self.winid=self.get_hwnd()
        self.vis.destroy_window()
        self.vis = o3d.visualization.VisualizerWithEditing()
        self.vis.create_window(visible=False)
        
        #Embed window into widget
        self.sub_window = QWindow.fromWinId(self.winid)
        self.windowcontainer = QWidget.createWindowContainer(self.sub_window,self.ui.o3d_widget)
        layout=QGridLayout(self.ui.o3d_widget)
        layout.addWidget(self.windowcontainer,0,0)
        self.vis.add_geometry(pcd)
        
        #start a timmer in the main thread
        self.o3d_selectpoint_vis_timer.start(100)#Can not set too much otherwise will wait long time for first time
        
    def vis_run_cb(self):
        self.vis.run()
        self.vis.destroy_window()
        self.selected_points_list=self.vis.get_picked_points()
        
        self.o3d_selectpoint_vis_timer.stop()
        
        
if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

Thanks to everyone for discussing this problem here too much, meanwhile I am also curious about whether can we just move the open3d window into the middle of QT UI, but not embed it into QT? Maybe this will be much more convenient.

[rrmsm]

@elevenjiang1 Why does the program appear unresponsive after 5 seconds?

[ICO-Fantasy]

I wirte an example with help of gemini。
python == 3.11.13
pyside == 6.9.0

import sys
import uuid

import numpy as np
import open3d as o3d
import win32api
import win32con
import win32gui
from loguru import logger
from PySide6.QtCore import Qt, QTimer, Signal
from PySide6.QtGui import QWindow
from PySide6.QtWidgets import (
    QApplication,
    QFrame,
    QHBoxLayout,
    QLabel,
    QPushButton,
    QScrollArea,
    QVBoxLayout,
    QWidget,
)

# ---------------------------------------------------------
# 1. 核心渲染组件：O3DViewerWidget (API 承载体)
# ---------------------------------------------------------


class O3DViewerWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.unique_name = f"O3D_{uuid.uuid4().hex[:8]}"
        # 关闭 o3d 警告
        o3d.utility.set_verbosity_level(o3d.utility.VerbosityLevel.Error)
        self.vis: o3d.visualization.Visualizer = o3d.visualization.Visualizer()
        self.hwnd = 0
        self._is_cleaned = False
        self.default_zoom = 0.7
        # 用于记录鼠标状态，实现“点击”检测（边缘触发）
        self._was_ctrl_lbutton_down = False
        # 几何体管理
        self._geometries: dict[str, o3d.geometry.Geometry] = {}
        self._show_origin_axis = False
        self._helpers_data = {"bboxes": {}, "others": {}, "select_points": {}}
        self._select_points: list[np.ndarray] = []
        self._origin_axis = o3d.geometry.TriangleMesh.create_coordinate_frame(size=0.5, origin=[0, 0, 0])
        self._setup_ui()
        self._init_open3d()
        self.destroyed.connect(self.cleanup)

    @property
    def helpers(self):
        """返回分类存储的辅助对象字典"""
        return self._helpers_data

    def _setup_ui(self):
        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
        self.setStyleSheet("background-color: black;")
        self._layout = QVBoxLayout(self)
        self._layout.setContentsMargins(0, 0, 0, 0)

    def _init_open3d(self):
        # 【方案一：坐标放逐】
        # 在创建时就把它丢到屏幕外（-9999），防止在屏幕中心闪现
        logger.debug(f"创建 Open3D 窗口 {self.unique_name}")
        self.vis.create_window(
            window_name=self.unique_name,
            width=640,
            height=480,
            visible=True,
            left=-9999,
            top=-9999,  # 核心点：开在看不见的地方
        )
        # 获取视图控制器
        view_ctl = self.vis.get_view_control()
        # 设置正交投影
        current_fov = view_ctl.get_field_of_view()
        # logger.debug(f"当前 FOV :{current_fov}")
        fov_step = 5 - current_fov  # for example self.target_fov == 5
        view_ctl.change_field_of_view(step=fov_step)
        # logger.debug(f"修改后 FOV :{view_ctl.get_field_of_view()}")

        self.hwnd = win32gui.FindWindowEx(0, 0, None, self.unique_name)

        if self.hwnd:
            # 【方案二：强制抹除窗口样式】
            # 去掉标题栏、边框、系统菜单。这让它变成一个纯粹的“像素矩形”
            style = win32gui.GetWindowLong(self.hwnd, win32con.GWL_STYLE)
            style &= ~win32con.WS_CAPTION
            win32gui.SetWindowLong(self.hwnd, win32con.GWL_STYLE, style)

            self.o3d_window = QWindow.fromWinId(self.hwnd)
            self.container = QWidget.createWindowContainer(self.o3d_window, self)
            self._layout.addWidget(self.container)

            # 初始时让它在容器内也是隐藏的，直到第一次 Resize 确定大小
            win32gui.ShowWindow(self.hwnd, win32con.SW_HIDE)

            self.timer = QTimer(self)
            self.timer.timeout.connect(self._render_loop)
            self.timer.start(16)

    def _render_loop(self):
        """渲染循环：Open3D 所有的 API 都在这里执行，确保线程安全"""
        if self._is_cleaned:
            return

        # 1. Open3D 正常的事件处理和渲染
        self.vis.poll_events()
        self.vis.update_renderer()

        # 2. 安全的输入轮询 (Input Polling)
        self._check_input_picking()

    def _check_input_picking(self):
        """在渲染循环中安全地检查鼠标状态"""
        # 获取 Ctrl 键和鼠标左键的实时状态
        # 0x8000 表示按键当前处于按下状态
        ctrl_down = win32api.GetKeyState(win32con.VK_CONTROL) & 0x8000
        lbutton_down = win32api.GetKeyState(win32con.VK_LBUTTON) & 0x8000

        current_state = bool(ctrl_down and lbutton_down)

        # 边缘触发检测：只有在“刚按下”那一瞬间触发
        if current_state and not self._was_ctrl_lbutton_down:
            cursor_pos = win32api.GetCursorPos()  # 全局屏幕坐标
            try:
                local_pos = win32gui.ScreenToClient(self.hwnd, cursor_pos)
                x, y = local_pos

                rect = win32gui.GetClientRect(self.hwnd)
                w, h = rect[2], rect[3]

                # 如果点击在有效范围内
                if 0 <= x <= w and 0 <= y <= h:
                    # logger.debug(f"检测到安全点选请求：({x}, {y})")
                    # 使用统一的深度拾取逻辑
                    self.pick_point_from_depth(x, y)
            except Exception as e:
                logger.error(f"坐标转换异常：{e}")

        self._was_ctrl_lbutton_down = current_state

    # region Qt 事件重写

    def hideEvent(self, event):
        """当父级 hide 或注销时，在任何动作之前先致盲"""
        if self.hwnd and not self._is_cleaned:
            # 极速隐藏
            win32gui.ShowWindow(self.hwnd, win32con.SW_HIDE)
            # 丢出屏幕
            win32gui.SetWindowPos(self.hwnd, 0, -9999, -9999, 0, 0, win32con.SWP_NOZORDER | win32con.SWP_NOSIZE)
        super().hideEvent(event)

    def showEvent(self, event):
        if self.hwnd and not self._is_cleaned:
            win32gui.ShowWindow(self.hwnd, win32con.SW_SHOW)
        super().showEvent(event)

    def resizeEvent(self, event):
        super().resizeEvent(event)
        # 如果资源已清理或句柄无效，直接返回
        if self._is_cleaned or not self.hwnd:
            return
        # 核心逻辑：只有尺寸有效时才同步
        if self._is_initialized_size():
            w, h = event.size().width(), event.size().height()

            # 同步 Win32 窗口位置和大小
            # SWP_SHOWWINDOW 确保在获得正确尺寸的瞬间才真正显示窗口
            win32gui.SetWindowPos(
                self.hwnd, win32con.HWND_TOP, 0, 0, w, h, win32con.SWP_SHOWWINDOW | win32con.SWP_NOZORDER
            )

            # 通知 Open3D 内部渲染器窗口大小已改变
            # 有些 O3D 版本需要 poll_events 才能捕捉到尺寸变化
            self.vis.poll_events()
            self.vis.update_renderer()

    # endregion
    def _is_initialized_size(self) -> bool:
        """
        检查 Widget 是否已经获得了由布局管理器分配的有效尺寸。
        通常 Qt 在初始化的几毫秒内会产生 (0,0) 或 (1,1) 的尺寸。
        """
        size = self.size()
        return size.width() > 1 and size.height() > 1

    def cleanup(self):
        if self._is_cleaned:
            return
        self._is_cleaned = True
        logger.debug(f"清理 Open3D 窗口 {self.unique_name}")
        if hasattr(self, "timer") and self.timer:
            self.timer.stop()

        try:
            if self.hwnd:
                # 【方案三：断后逻辑】
                # 1. 先设置透明度为 0（如果系统支持）或直接隐藏
                win32gui.ShowWindow(self.hwnd, win32con.SW_HIDE)
                # 2. 再次放逐到远方
                win32gui.SetWindowPos(self.hwnd, 0, -9999, -9999, 0, 0, win32con.SWP_NOZORDER)
                # 3. 解除父子关系
                win32gui.SetParent(self.hwnd, 0)

            if self.vis:
                # 4. 强制销毁
                self.vis.destroy_window()
                self.vis = None
        except Exception as e:
            logger.error(f"清理出错：{e}")

    # region 几何体操作 API (重构版)

    def add_point_cloud(self, name: str, geometry, reset_view=True):
        """添加核心业务几何体（点云等），允许根据需求重置视角"""
        self.remove_geometry(name)
        self._geometries[name] = geometry
        # 添加主几何体时，根据参数决定是否重置包围盒（即相机视角）
        self.vis.add_geometry(geometry, reset_bounding_box=reset_view)
        self.vis.update_geometry(geometry)
        self._display_axis()

    def add_helper_geometry(self, name: str, geometry, helper_type: str = "others"):
        """添加辅助几何体（标记、框、轴），严格禁止相机跳变"""
        self.remove_geometry(name)
        if helper_type not in self._helpers_data:
            helper_type = "others"
        self._helpers_data[helper_type][name] = geometry

        self.vis.add_geometry(geometry, reset_bounding_box=False)
        self.vis.update_geometry(geometry)

    def remove_geometry(self, name: str):
        """全量搜索并移除几何体"""
        if name in self._geometries:
            self.vis.remove_geometry(self._geometries.pop(name), reset_bounding_box=False)
            return
        for category in self._helpers_data.values():
            if name in category:
                self.vis.remove_geometry(category.pop(name), reset_bounding_box=False)
                return

    def remove_point_cloud(self, name: str):
        """移除核心业务几何体（点云等）"""
        if name in self._geometries:
            self.vis.remove_geometry(self._geometries.pop(name), reset_bounding_box=False)
            self._display_axis()

    def remove_select_point(self):
        for point in self.helpers["select_points"].values():
            self.vis.remove_geometry(point, reset_bounding_box=False)

    def _calculate_origin_axis(self):
        # 1. 获取场景在各维度上的跨度
        extents = self._calculate_combined_bounds()
        max_dim = np.max(extents)

        # 2. 计算坐标轴尺寸
        # 建议比例：最大维度的 20% (0.2)。这样既能看清，又不会遮挡点云。
        size = max_dim * 0.2

        # 3. 动态最小值处理
        # 如果场景为空或物体极小（比如 max_dim 为 0），
        # 我们不能直接设为 1，而应该根据场景是否为空来决定。
        if size <= 0:
            size = 1.0  # 场景为空时的默认大小
        elif size < 0.01:
            # 如果是微观点云（如毫米级以下），坐标轴不应强制为 1
            # 这里可以不设下限，或者设为一个更小的感官阈值
            pass

        # 4. 创建坐标轴
        # origin=[0, 0, 0] 确保坐标轴始终在世界坐标系的原点
        return o3d.geometry.TriangleMesh.create_coordinate_frame(size=size, origin=[0, 0, 0])

    @property
    def show_origin_axis(self):
        return self._show_origin_axis

    @show_origin_axis.setter
    def show_origin_axis(self, show: bool):
        self._show_origin_axis = show
        self._display_axis()

    def _display_axis(self):
        """移除坐标轴辅助对象"""
        if not self._origin_axis:
            return
        self.vis.remove_geometry(self._origin_axis)
        self._origin_axis = None
        if not self._show_origin_axis:
            return
        self._origin_axis = self._calculate_origin_axis()
        self.vis.add_geometry(self._origin_axis, reset_bounding_box=False)

    def remove_bounding_box(self, name: str):
        """移除包围框辅助对象"""
        if name in self.helpers["bounding_box"]:
            self.vis.remove_geometry(self.helpers["bounding_box"].pop(name), reset_bounding_box=False)
            return

    def add_bounding_box(self, name: str, geometry):
        """添加包围框辅助对象"""
        self.add_helper_geometry(name, geometry, helper_type="bounding_box")

    def add_select_point(self, name: str, coord: np.ndarray):
        """添加选中点辅助对象"""
        self._select_points.append(coord)
        dynamic_radius = self._get_dynamic_marker_radius()

        sphere = o3d.geometry.TriangleMesh.create_sphere(radius=dynamic_radius)
        sphere.paint_uniform_color([1, 0, 0])  # 红色标记
        sphere.translate(coord)
        self.add_helper_geometry(name, sphere, helper_type="select_points")

    # endregion

    def clear_geometries(self):
        """清空核心点云数据，保留辅助对象"""
        names = list(self._geometries.keys())
        for n in names:
            self.remove_geometry(n)

    # region 视角控制
    def _get_all_visible_geometries(self):
        """获取所有已加载的几何体列表"""
        return list(self._geometries.values()) + list(
            [item for sublist in self._helpers_data.values() for item in sublist.values()]
        )

    def _calculate_combined_bounds_center(self):
        """计算所有几何体的合并包围盒中心"""
        all_geos = self._get_all_visible_geometries()
        if not all_geos:
            return np.array([0.0, 0.0, 0.0])

        # 提取所有物体的 min_bound 和 max_bound
        mins = [g.get_min_bound() for g in all_geos]
        maxs = [g.get_max_bound() for g in all_geos]

        global_min = np.min(mins, axis=0)
        global_max = np.max(maxs, axis=0)
        return (global_min + global_max) / 2.0

    def _calculate_combined_bounds(self):
        """计算所有几何体的合并包围盒尺寸"""
        all_geos = self._get_all_visible_geometries()
        if not all_geos:
            return np.array([0.0, 0.0, 0.0])

        # 提取所有物体的 min_bound 和 max_bound
        mins = [g.get_min_bound() for g in all_geos]
        maxs = [g.get_max_bound() for g in all_geos]

        global_min = np.min(mins, axis=0)
        global_max = np.max(maxs, axis=0)
        return global_max - global_min

    def _calculate_combined_center(self):
        """基于所有（包含辅助对象）几何体计算合并中心"""
        all_objs = list(self._geometries.values())
        for cat in self._helpers_data.values():
            all_objs.extend(list(cat.values()))

        if not all_objs:
            return np.array([0, 0, 0])

        mins = [obj.get_min_bound() for obj in all_objs]
        maxs = [obj.get_max_bound() for obj in all_objs]
        return (np.min(mins, axis=0) + np.max(maxs, axis=0)) / 2.0

    def set_standard_view(self, view_name: str, zoom: float = None):
        """设置标准化视角"""
        view_ctl = self.vis.get_view_control()
        if not view_ctl:
            return

        center = self._calculate_combined_center()
        zoom = zoom or self.default_zoom

        views = {
            "front": {"front": [0, 0, -1], "up": [0, 1, 0]},
            "back": {"front": [0, 0, 1], "up": [0, 1, 0]},
            "top": {"front": [0, -1, 0], "up": [0, 0, -1]},
            "bottom": {"front": [0, 1, 0], "up": [0, 0, 1]},
            "left": {"front": [1, 0, 0], "up": [0, 1, 0]},
            "right": {"front": [-1, 0, 0], "up": [0, 1, 0]},
            "iso": {"front": [-1, -1, -1], "up": [0, 1, 0]},
        }

        conf = views.get(view_name.lower(), views["front"])
        view_ctl.set_lookat(center)
        view_ctl.set_front(np.array(conf["front"]))
        view_ctl.set_up(np.array(conf["up"]))
        view_ctl.set_zoom(zoom)

        # 设置一个较大的远裁剪面，防止深度图在远处被截断
        view_ctl.set_constant_z_far(2000.0)
        view_ctl.set_constant_z_near(0.1)

        self.vis.poll_events()
        self.vis.update_renderer()

    def reset_view(self):
        self.set_standard_view("front")

    # endregion

    # region 点选功能实现

    def pick_point_from_depth(self, x, y):
        """利用深度缓冲区实现精准点选"""
        if self._is_cleaned:
            return

        try:
            # 获取深度图
            depth_img = self.vis.capture_depth_float_buffer(do_render=True)
            depth_data = np.asarray(depth_img)

            h, w = depth_data.shape
            if x >= w or y >= h or x < 0 or y < 0:
                return

            z_depth = depth_data[y, x]

            # 【修复点选错误】
            # 这里的 z_depth 是物理深度（如 340.47mm）。
            # 背景的深度通常被 Open3D 设为 0 或者非常大的远裁剪面值。
            # 我们只需要排除 0 或无效值。
            if z_depth <= 0.0:
                # logger.debug(f"点击位置无深度信息 (背景)")
                return

            # 如果 z_depth 特别大（接近远裁剪面），也视为背景
            # 这里取 999 只是一个经验值，取决于 set_constant_z_far 的设置
            if z_depth > 2000.0:
                # logger.debug(f"点击位置在远裁剪面之外 (z={z_depth})")
                return

            view_ctl = self.vis.get_view_control()
            cam_params = view_ctl.convert_to_pinhole_camera_parameters()
            intrinsic = cam_params.intrinsic.intrinsic_matrix
            extrinsic = cam_params.extrinsic

            # 反求 3D 坐标逻辑 (保持数学准确性)
            z = z_depth
            cx, cy = intrinsic[0, 2], intrinsic[1, 2]
            fx, fy = intrinsic[0, 0], intrinsic[1, 1]

            cam_x = (x - cx) * z / fx
            cam_y = (y - cy) * z / fy
            cam_pos = np.array([cam_x, cam_y, z, 1.0])

            world_pos = np.linalg.inv(extrinsic) @ cam_pos
            actual_xyz = world_pos[:3]

            self._add_selection_mark(actual_xyz)
            logger.debug(f"点选成功：{actual_xyz}")

        except Exception as e:
            logger.error(f"深度拾取异常：{e}")

    def _get_dynamic_marker_radius(self):
        """根据当前场景所有物体的包围盒动态计算标记球半径"""
        all_geos = self._get_all_visible_geometries()
        if not all_geos:
            return 0.01

        # 计算合并后的包围盒
        mins = [g.get_min_bound() for g in all_geos]
        maxs = [g.get_max_bound() for g in all_geos]
        global_min = np.min(mins, axis=0)
        global_max = np.max(maxs, axis=0)

        # 取包围盒对角线长度的 0.5% 作为半径
        extent = np.linalg.norm(global_max - global_min)
        return extent * 0.005 if extent > 0 else 0.01

    def _add_selection_mark(self, coord):
        """添加辅助标记球"""
        name = f"mark_{uuid.uuid4().hex[:4]}"
        self.add_select_point(name, coord)

        # 强制刷新界面
        self.vis.poll_events()
        self.vis.update_renderer()

    def clear_select_points(self):
        """清除所有选中标记"""
        for name in list(self._helpers_data["select_points"].keys()):
            self.remove_geometry(name)
        self._select_points.clear()

    def get_selct_points(self):
        res = self._select_points.copy()
        self.clear_select_points()
        return res

    # endregion

    def set_background_color(self, r, g, b):
        self.vis.get_render_option().background_color = np.asarray([r, g, b])

    def set_point_size(self, size):
        self.vis.get_render_option().point_size = size


# ---------------------------------------------------------
# 2. 业务封装窗口：O3DViewerWindow
# ---------------------------------------------------------
class O3DViewerWindow(QWidget):
    closed = Signal()

    def __init__(self, title="3D Viewer", size=(1024, 768), stay_on_top=False):
        super().__init__()
        self.setWindowTitle(title)
        self.resize(*size)
        if stay_on_top:
            self.setWindowFlags(Qt.WindowType.Window | Qt.WindowType.WindowStaysOnTopHint)

        self.viewer = O3DViewerWidget(self)
        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.addWidget(self.viewer)

    def closeEvent(self, event):
        # 1. 立即从屏幕上消失，这是防止一切闪烁的第一步
        self.setVisible(False)
        # 2. 触发内部清理
        self.viewer.cleanup()
        self.closed.emit()
        event.accept()


# ---------------------------------------------------------
# 3. 演示示例：带几何体列表的 Demo
# ---------------------------------------------------------
class GeometryListItem(QFrame):
    """列表中的单行组件"""

    toggled = Signal(str, bool)

    def __init__(self, name):
        super().__init__()
        self.name = name
        self.is_visible = True
        self.setFrameShape(QFrame.Shape.StyledPanel)
        self.setStyleSheet("background-color: #333; color: white; border-radius: 4px; margin: 2px;")

        layout = QHBoxLayout(self)
        layout.setContentsMargins(10, 5, 10, 5)

        self.label = QLabel(name)
        self.btn_eye = QPushButton("👁")  # 借用 Emoji 作为图标
        self.btn_eye.setFixedWidth(40)
        self.btn_eye.setCheckable(True)
        self.btn_eye.setChecked(True)
        self.btn_eye.setStyleSheet(
            "QPushButton { border: none; font-size: 16px; } QPushButton:checked { color: #00FF00; }"
        )

        layout.addWidget(self.label)
        layout.addStretch()
        layout.addWidget(self.btn_eye)

        self.btn_eye.clicked.connect(self._on_toggle)

    def _on_toggle(self, checked):
        self.btn_eye.setText("👁" if checked else "❌")
        self.toggled.emit(self.name, checked)


class ListDemoWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Open3D Component Demo")
        self.resize(1200, 800)

        # 主布局：左右分割
        main_layout = QHBoxLayout(self)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.setSpacing(0)

        # 1. 左侧：3D 视图 (使用我们的 Widget)
        self.viewer = O3DViewerWidget()
        main_layout.addWidget(self.viewer, stretch=4)

        # 2. 右侧：控制面板
        self.panel = QWidget()
        self.panel.setFixedWidth(250)
        self.panel.setStyleSheet("background-color: #222; border-left: 1px solid #444;")
        panel_layout = QVBoxLayout(self.panel)

        title = QLabel("几何体列表")
        title.setStyleSheet("color: white; font-weight: bold; font-size: 18px; margin: 10px;")
        panel_layout.addWidget(title)

        # 滚动区域存放列表
        self._scroll = QScrollArea()
        self._scroll.setWidgetResizable(True)
        self._scroll.setStyleSheet("border: none; background: transparent;")
        self.list_container = QWidget()
        self.list_layout = QVBoxLayout(self.list_container)
        self.list_layout.addStretch()  # 把项目往上挤
        self._scroll.setWidget(self.list_container)
        panel_layout.addWidget(self._scroll)

        main_layout.addWidget(self.panel)

        # 初始化一些测试数据
        self.setup_demo_data()

    def setup_demo_data(self):
        # 设置背景色
        self.viewer.set_background_color(0.1, 0.1, 0.1)

        # 1. 添加一个球体
        sphere = o3d.geometry.TriangleMesh.create_sphere(radius=1.0)
        sphere.compute_vertex_normals()
        sphere.paint_uniform_color([1, 0.7, 0.3])
        self.add_item_to_viewer("Golden_Sphere", sphere)

        # 2. 添加一个坐标轴
        axes = o3d.geometry.TriangleMesh.create_coordinate_frame(size=2.0)
        self.add_item_to_viewer("World_Axes", axes)

        # 3. 添加一个随机点云
        pts = np.random.uniform(-2, 2, (10000, 3))
        cols = np.random.uniform(0.4, 1, (10000, 3))
        self.viewer.add_point_cloud("Random_Cloud", pts, cols)
        self._create_list_widget("Random_Cloud")  # 手动补个列表项

    def add_item_to_viewer(self, name, geom):
        self.viewer.add_point_cloud(name, geom)
        self._create_list_widget(name)

    def _create_list_widget(self, name):
        item_ui = GeometryListItem(name)
        # item_ui.toggled.connect(self.viewer.set_geometry_visible)
        # 插入到最前面
        self.list_layout.insertWidget(self.list_layout.count() - 1, item_ui)


if __name__ == "__main__":
    # 环境路径设置
    pyside6_dir = os.path.join(sys.prefix, "Lib", "site-packages", "PySide6")
    os.environ["QT_PLUGIN_PATH"] = os.path.join(pyside6_dir, "plugins")
    os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = os.path.join(pyside6_dir, "plugins", "platforms")

    app = QApplication(sys.argv)
    demo = ListDemoWindow()
    demo.show()
    sys.exit(app.exec())

[ebhrz]

Since we don't have win32gui on linux, how can I use it on Linux?

[zapplelove]

(https://stackoverflow.com/questions/58816766/how-to-embed-a-pptk-viewer-in-a-pyqt5-window)

here is the example demo on linux instead of using win32gui:

from PyQt5 import QtWidgets, QtGui,QtCore
import open3d as o3d
from subprocess import Popen, PIPE
# import win32gui
import sys

class MainWindow(QtWidgets.QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        widget = QtWidgets.QWidget()
        layout = QtWidgets.QGridLayout(widget)
        self.setCentralWidget(widget)

        pcd = o3d.io.read_point_cloud("example.pcd")
        self.vis = o3d.visualization.Visualizer()
        self.vis.create_window()
        self.vis.add_geometry(pcd)

        # hwnd = win32gui.FindWindowEx(0, 0, None, "Open3D")
        hwnd = self.get_hwnd()
        self.window = QtGui.QWindow.fromWinId(hwnd)    
        self.windowcontainer = self.createWindowContainer(self.window, widget)
        layout.addWidget(self.windowcontainer, 0, 0)
        timer = QtCore.QTimer(self)
        timer.timeout.connect(self.update_vis)
        timer.start(1)

    def get_hwnd(self):
        hwnd = None
        while hwnd == None:
            proc = Popen('wmctrl -l', stdin=None, stdout=PIPE, stderr=None, shell=True)
            out, err = proc.communicate()
            for window in out.decode('utf-8').split('\n'):
                if 'Open3D' in window:
                    hwnd = int(window.split(' ')[0], 16)
                    return hwnd

    def update_vis(self):
        #self.vis.update_geometry()
        self.vis.poll_events()
        self.vis.update_renderer()

if __name__ == '__main__':

    app = QtWidgets.QApplication(sys.argv)
    form = MainWindow()
    form.setWindowTitle('o3d Embed')
    form.setGeometry(100, 100, 600, 500)
    form.show()
    sys.exit(app.exec_())

[HongruiTang]

I used pyqtgraph.opengl to show 3d pointcloud at last

Hi, can you share your code on linux or mac?

[WonjaeChoi0712]

Hello, I am looking for a solution for mac os(m2 chip).
I tried to get the hwnd through Quartz module but wasn't successful :(
Does anyone have any ideas on this issue??

[ebhrz]

Sorry for late reply, I just saw it. Here's my code

from PyQt5.QtWidgets import QProgressDialog, QFileDialog,QMainWindow,QApplication,QMessageBox,QDialog, QGraphicsScene, QGraphicsPixmapItem
from PyQt5.QtGui import QImage,QPixmap
import pyqtgraph as pg
import pyqtgraph.opengl as gl
from OpenGL.GL import GL_ONE, GL_BLEND
from OpenGL.GL.EXT.blend_minmax import GL_MAX_EXT
from ui.mainwin import Ui_MainWindow # Your layout

class MyApp(QMainWindow, Ui_MainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        Ui_MainWindow.__init__(self)
        # here to add the pyqtgraph opengl to a named widget defined in ui
        self.setupUi(self)
        self.glwidget = gl.GLViewWidget()
        g = gl.GLGridItem()
        g.scale(10, 10, 1)
        self.glwidget.addItem(g)
        # this is the name
        self.verticalLayout.addWidget(self.glwidget)

    def gen3d(self):
        # volume is a series of image here, just change to what you need
        tmp = np.zeros((*self.volume.shape,4))
        t1 = self.volume.copy()
        tmp[:,:,:,0]=t1+50
        tmp[:,:,:,1]=t1+50
        tmp[:,:,:,2]=t1+50
        tmp[:,:,:,3]=10
        tmp = np.transpose(tmp,[0,2,1,3])
        v = gl.GLVolumeItem(tmp)
        v.translate(-50,-256,-256)
        v.rotate(180,0,1,0)
        #v.setGLOptions({'glBlendFunc': (GL_ONE, GL_ONE), 'glBlendEquation': (GL_MAX_EXT, ), GL_BLEND: True})
        self.glwidget.clear()
        self.glwidget.addItem(v)
if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MyApp()
    window.show()
    sys.exit(app.exec_())

@HongruiTang
@WonjaeChoi0712 This works on my intel mac, I think it should also work on m2.

[yusufguleray]

@zapplelove Thanks for the nice example code.
But I am getting the error:

QWindow::fromWinId(): platform plugin does not support foreign windows.
QWindowContainer: embedded window cannot be null

fort the line:
self.window = QtGui.QWindow.fromWinId(hwnd)
ever thought the get_hwnd() seem to work fine.

Any idea why this happening or how can I fix it?