q3dviewer 1.0.7__tar.gz → 1.1.1__tar.gz

q3dviewer-1.1.1/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+
+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.

q3dviewer-1.1.1/PKG-INFO

@@ -0,0 +1,205 @@
+Metadata-Version: 2.1
+Name: q3dviewer
+Version: 1.1.1
+Summary: A library designed for quickly deploying a 3D viewer.
+Home-page: https://github.com/scomup/q3dviewer
+Author: Liu Yang
+License: UNKNOWN
+Description: ## q3dviewer
+        
+        `q3dviewer` is a library designed for quickly deploying a 3D viewer. It is based on Qt (PySide6) and provides efficient OpenGL items for displaying 3D objects (e.g., point clouds, cameras, and 3D Gaussians). You can use it to visualize your 3D data or set up an efficient viewer application. It is inspired by PyQtGraph but focuses more on efficient 3D rendering.
+        
+        ## Installation
+        
+        To install `q3dviewer`, execute the following command in your terminal on either Linux or Windows:
+        
+        ```bash
+        pip install q3dviewer
+        ```
+        
+        ### Note for Windows Users
+        
+        - Ensure that you have a Python 3 environment set up:
+          - Download and install Python 3 from the [official Python website](https://www.python.org/downloads/).
+          - During installation, make sure to check the "Add Python to PATH" option.
+        
+        ### Note for Linux Users
+        
+        If you encounter an error related to loading the shared library `libxcb-cursor.so.0` on Ubuntu 20.04 or 22.04, please install `libxcb-cursor0`:
+        
+        ```bash
+        sudo apt-get install libxcb-cursor0
+        ```
+        
+        ## Tools
+        
+        Once installed, you can directly use the following tools:
+        
+        ### 1. Cloud Viewer
+        
+        A tool for visualizing point cloud files. Launch it by executing the following command in your terminal:
+        
+        ```sh
+        cloud_viewer  # The viewer will be displayed
+        ```
+        
+        *Alternatively*, if the path is not set (though it's not recommended):
+        
+        ```sh
+        python3 -m q3dviewer.tools.cloud_viewer
+        ```
+        
+        After the viewer launches, you can drag and drop files onto the window to display the point clouds. Multiple files can be dropped simultaneously to view them together. Supported formats include LAS, PCD, PLY, and E57.
+        
+        For example, you can download and view point clouds of Tokyo in LAS format from the following link:
+        
+        [Tokyo Point Clouds](https://www.geospatial.jp/ckan/dataset/tokyopc-23ku-2024/resource/7807d6d1-29f3-4b36-b0c8-f7aa0ea2cff3)
+        
+        ![Cloud Viewer Screenshot](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/03c981c6-1aec-e5b9-4536-e07e1e56ff29.png)
+        
+        Press `M` on your keyboard to display a menu on the screen, where you can modify visualization settings for each item. For example, you can adjust various settings such as shape, size, color, and transparency for `CloudItem`.
+        
+        ![Cloud Viewer Settings](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/deeb996a-e419-58f4-6bc2-535099b1b73a.png)
+        
+        ### 2. ROS Viewer
+        
+        A high-performance SLAM viewer compatible with ROS, serving as an alternative to RVIZ.
+        
+        ```sh
+        roscore &
+        ros_viewer
+        ```
+        
+        ### 3. Film Maker
+        
+        Would you like to create a video from point cloud data? With Film Maker, you can easily create videos with simple operations. Just edit keyframes using the user-friendly GUI, and the software will automatically interpolate the keyframes to generate the video.
+        
+        ```sh
+        film_maker # drag and drop your cloud file to the window
+        ```
+        
+        * Space key to add a keyframe.
+        * Delete key to remove a keyframe.
+        
+        Film Maker GUI: 
+        
+        ![Screenshot from 2025-02-02 18-20-51.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/a1a6ad63-237c-482e-439d-e760223c59ca.png)
+        
+        ### 4. Gaussian Viewer
+        
+        A simple viewer for 3D Gaussians. See [EasyGaussianSplatting](https://github.com/scomup/EasyGaussianSplatting) for more information.
+        
+        ```sh
+        gaussian_viewer  # Drag and drop your Gaussian file onto the window
+        ```
+        
+        ![Gaussian Viewer GIF](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/441e6f5a-214d-f7c1-11bf-5fa79e63b38e.gif)
+        
+        ### 5. LiDAR-LiDAR Calibration Tools
+        
+        A tool to compute the relative pose between two LiDARs. It allows for both manual adjustment in the settings screen and automatic calibration.
+        
+        ```sh
+        lidar_calib --lidar0=/YOUR_LIDAR0_TOPIC --lidar1=/YOUR_LIDAR1_TOPIC
+        ```
+        
+        ![LiDAR Calibration](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/5a8a9903-a42a-8322-1d23-0cbecd3fa99a.png)
+        
+        ### 6. LiDAR-Camera Calibration Tools
+        
+        A tool for calculating the relative pose between a LiDAR and a camera. It allows for manual adjustment in the settings screen and real-time verification of LiDAR point projection onto images.
+        
+        ```sh
+        lidar_cam_calib --lidar=/YOUR_LIDAR_TOPIC --camera=/YOUR_CAMERA_TOPIC --camera_info=/YOUR_CAMERA_INFO_TOPIC
+        ```
+        
+        ![LiDAR-Camera Calibration](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/f8359820-2ae7-aa37-6577-0fa035f4dd95.png)
+        
+        ## Using as a Library
+        
+        Using the examples above, you can easily customize and develop your own 3D viewer with `q3dviewer`. Below is a coding example.
+        
+        ### Custom 3D Viewer
+        
+        ```python
+        #!/usr/bin/env python3
+        
+        import q3dviewer as q3d  # Import q3dviewer
+        
+        def main():
+            # Create a Qt application
+            app = q3d.QApplication([])
+        
+            # Create various 3D items
+            axis_item = q3d.AxisItem(size=0.5, width=5)
+            grid_item = q3d.GridItem(size=10, spacing=1)
+        
+            # Create a viewer
+            viewer = q3d.Viewer(name='example')
+            
+            # Add items to the viewer
+            viewer.add_items({
+                'grid': grid_item,
+                'axis': axis_item,
+            })
+        
+            # Show the viewer & run the Qt application
+            viewer.show()
+            app.exec()
+        
+        if __name__ == '__main__':
+            main()
+        ```
+        
+        `q3dviewer` provides the following 3D items:
+        
+        - **AxisItem**: Displays coordinate axes or the origin position.
+        - **CloudItem**: Displays point clouds.
+        - **CloudIOItem**: Displays point clouds with input/output capabilities.
+        - **GaussianItem**: Displays 3D Gaussians.
+        - **GridItem**: Displays grids.
+        - **ImageItem**: Displays 2D images.
+        - **Text2DItem**: Displays 2D text.
+        - **LineItem**: Displays lines or trajectories.
+        
+        ### Developing Custom Items
+        
+        In addition to the standard 3D items provided, you can visualize custom 3D items with simple coding. Below is a sample:
+        
+        ```python
+        from OpenGL.GL import *
+        import numpy as np
+        import q3dviewer as q3d
+        from PySide6.QtWidgets import QLabel, QSpinBox
+        
+        class YourItem(q3d.BaseItem):
+            def __init__(self):
+                super(YourItem, self).__init__()
+                # Necessary initialization
+        
+            def add_setting(self, layout):
+                # Initialize the settings screen
+                label = QLabel("Add your setting:")
+                layout.addWidget(label)
+                box = QSpinBox()
+                layout.addWidget(box)
+        
+            def set_data(self, data):
+                # Obtain the data you want to visualize
+                pass
+        
+            def initialize_gl(self):
+                # OpenGL initialization settings (if needed)
+                pass
+        
+            def paint(self):
+                # Visualize 3D objects using OpenGL
+                pass
+        ```
+        
+        Enjoy using `q3dviewer`!
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown

{q3dviewer-1.0.7 → q3dviewer-1.1.1}/README.md

@@ -1,6 +1,6 @@
 ## q3dviewer
 
-`q3dviewer` is a library designed for quickly deploying a 3D viewer. It is based on Qt (pyside6) and provides efficient OpenGL items for displaying 3D objects (e.g., point clouds, cameras, and 3D Gaussians). You can use it to visualize your 3D data or set up an efficient viewer application. It is inspired by PyQtGraph, but it focuses more on efficient 3D rendering.
+`q3dviewer` is a library designed for quickly deploying a 3D viewer. It is based on Qt (PySide6) and provides efficient OpenGL items for displaying 3D objects (e.g., point clouds, cameras, and 3D Gaussians). You can use it to visualize your 3D data or set up an efficient viewer application. It is inspired by PyQtGraph but focuses more on efficient 3D rendering.
 
 ## Installation
 
@@ -16,6 +16,14 @@ pip install q3dviewer
   - Download and install Python 3 from the [official Python website](https://www.python.org/downloads/).
   - During installation, make sure to check the "Add Python to PATH" option.
 
+### Note for Linux Users
+
+If you encounter an error related to loading the shared library `libxcb-cursor.so.0` on Ubuntu 20.04 or 22.04, please install `libxcb-cursor0`:
+
+```bash
+sudo apt-get install libxcb-cursor0
+```
+
 ## Tools
 
 Once installed, you can directly use the following tools:
@@ -26,44 +34,61 @@ A tool for visualizing point cloud files. Launch it by executing the following c
 
 ```sh
 cloud_viewer  # The viewer will be displayed
-# Use the command below if the path is not set, though it's not recommended
+```
+
+*Alternatively*, if the path is not set (though it's not recommended):
+
+```sh
 python3 -m q3dviewer.tools.cloud_viewer
 ```
 
 After the viewer launches, you can drag and drop files onto the window to display the point clouds. Multiple files can be dropped simultaneously to view them together. Supported formats include LAS, PCD, PLY, and E57.
 
-For example, you can download and check point clouds of Tokyo in LAS format from the following link:
+For example, you can download and view point clouds of Tokyo in LAS format from the following link:
 
 [Tokyo Point Clouds](https://www.geospatial.jp/ckan/dataset/tokyopc-23ku-2024/resource/7807d6d1-29f3-4b36-b0c8-f7aa0ea2cff3)
 
-![Screenshot](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/03c981c6-1aec-e5b9-4536-e07e1e56ff29.png)
+![Cloud Viewer Screenshot](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/03c981c6-1aec-e5b9-4536-e07e1e56ff29.png)
 
-Press `M` on your keyboard to display a menu on the screen, where you can modify visualization settings for each item. for example, You can adjust various settings such as shape, size, color, and transparency of the point clouds for CloudItem,.
+Press `M` on your keyboard to display a menu on the screen, where you can modify visualization settings for each item. For example, you can adjust various settings such as shape, size, color, and transparency for `CloudItem`.
 
-![Screenshot](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/deeb996a-e419-58f4-6bc2-535099b1b73a.png)
+![Cloud Viewer Settings](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/deeb996a-e419-58f4-6bc2-535099b1b73a.png)
 
 ### 2. ROS Viewer
 
-A high-performance SLAM viewer with strong compatibility with ROS, serving as an alternative to RVIZ.
+A high-performance SLAM viewer compatible with ROS, serving as an alternative to RVIZ.
 
 ```sh
 roscore &
 ros_viewer
 ```
 
-### 3. Gaussian Viewer
+### 3. Film Maker
+
+Would you like to create a video from point cloud data? With Film Maker, you can easily create videos with simple operations. Just edit keyframes using the user-friendly GUI, and the software will automatically interpolate the keyframes to generate the video.
+
+```sh
+film_maker # drag and drop your cloud file to the window
+```
+
+* Space key to add a keyframe.
+* Delete key to remove a keyframe.
+
+Film Maker GUI: 
+
+![Screenshot from 2025-02-02 18-20-51.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/a1a6ad63-237c-482e-439d-e760223c59ca.png)
 
-A simple viewer for 3D Gaussian.
-see: https://github.com/scomup/EasyGaussianSplatting
+### 4. Gaussian Viewer
 
+A simple viewer for 3D Gaussians. See [EasyGaussianSplatting](https://github.com/scomup/EasyGaussianSplatting) for more information.
 
 ```sh
 gaussian_viewer  # Drag and drop your Gaussian file onto the window
 ```
 
-![Viewer GIF](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/441e6f5a-214d-f7c1-11bf-5fa79e63b38e.gif)
+![Gaussian Viewer GIF](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/441e6f5a-214d-f7c1-11bf-5fa79e63b38e.gif)
 
-### 4. LiDAR-LiDAR Calibration Tools
+### 5. LiDAR-LiDAR Calibration Tools
 
 A tool to compute the relative pose between two LiDARs. It allows for both manual adjustment in the settings screen and automatic calibration.
 
@@ -73,7 +98,7 @@ lidar_calib --lidar0=/YOUR_LIDAR0_TOPIC --lidar1=/YOUR_LIDAR1_TOPIC
 
 ![LiDAR Calibration](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/5a8a9903-a42a-8322-1d23-0cbecd3fa99a.png)
 
-### 5. LiDAR-Camera Calibration Tools
+### 6. LiDAR-Camera Calibration Tools
 
 A tool for calculating the relative pose between a LiDAR and a camera. It allows for manual adjustment in the settings screen and real-time verification of LiDAR point projection onto images.
 
@@ -104,6 +129,7 @@ def main():
 
     # Create a viewer
     viewer = q3d.Viewer(name='example')
+    
     # Add items to the viewer
     viewer.add_items({
         'grid': grid_item,
@@ -120,14 +146,14 @@ if __name__ == '__main__':
 
 `q3dviewer` provides the following 3D items:
 
-- **AxisItem**: Displaying coordinate axes or self-position
-- **CloudItem**: Displaying point clouds
-- **CloudIOItem**: Displaying point clouds with I/O capabilities
-- **GaussianItem**: Displaying 3D Gaussians
-- **GridItem**: Displaying grids
-- **ImageItem**: Displaying 2D images
-- **Text2DItem**: Displaying 2D text
-- **LineItem**: Displaying lines or trajectories
+- **AxisItem**: Displays coordinate axes or the origin position.
+- **CloudItem**: Displays point clouds.
+- **CloudIOItem**: Displays point clouds with input/output capabilities.
+- **GaussianItem**: Displays 3D Gaussians.
+- **GridItem**: Displays grids.
+- **ImageItem**: Displays 2D images.
+- **Text2DItem**: Displays 2D text.
+- **LineItem**: Displays lines or trajectories.
 
 ### Developing Custom Items
 
@@ -142,7 +168,7 @@ from PySide6.QtWidgets import QLabel, QSpinBox
 class YourItem(q3d.BaseItem):
     def __init__(self):
         super(YourItem, self).__init__()
-        pass  # Necessary initialization
+        # Necessary initialization
 
     def add_setting(self, layout):
         # Initialize the settings screen
@@ -152,13 +178,16 @@ class YourItem(q3d.BaseItem):
         layout.addWidget(box)
 
     def set_data(self, data):
-        pass  # Obtain the data you want to visualize
+        # Obtain the data you want to visualize
+        pass
 
     def initialize_gl(self):
-        pass  # OpenGL initialization settings (if needed)
+        # OpenGL initialization settings (if needed)
+        pass
 
     def paint(self):
-        pass  # Visualize 3D objects using OpenGL
+        # Visualize 3D objects using OpenGL
+        pass
 ```
 
 Enjoy using `q3dviewer`!

q3dviewer-1.1.1/pyproject.toml

@@ -0,0 +1,26 @@
+[tool.poetry]
+name = "q3dviewer"
+version = "1.1.0"
+description = "A library designed for quickly deploying a 3D viewer."
+authors = ["Liu Yang <scomup@gmail.com>"]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+numpy = "^1.21"
+pyside6 = "^6.2"
+PyOpenGL = "^3.1"
+pillow = "^8.3"
+meshio = "^4.4"
+pypcd4 = "^0.1"
+pye57 = "^0.1"
+laspy = "^2.0"
+imageio = "^2.9"
+
+[tool.poetry.scripts]
+cloud_viewer = "q3dviewer.tools.cloud_viewer:main"
+ros_viewer = "q3dviewer.tools.ros_viewer:main"
+mesh_viewer = "q3dviewer.tools.mesh_viewer:main"
+gaussian_viewer = "q3dviewer.tools.gaussian_viewer:main"
+lidar_cam_calib = "q3dviewer.tools.lidar_cam_calib:main"
+lidar_calib = "q3dviewer.tools.lidar_calib:main"
+film_maker = "q3dviewer.tools.film_maker:main"

{q3dviewer-1.0.7 → q3dviewer-1.1.1}/q3dviewer/base_glwidget.py

@@ -25,6 +25,9 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         self.active_keys = set()
         self.show_center = False
         self.enable_show_center = True
+        self.view_need_update = True
+        self.view_matrix = self.get_view_matrix()
+        self.projection_matrix = self.get_projection_matrix()
 
     def keyPressEvent(self, ev: QtGui.QKeyEvent):
         if ev.key() == QtCore.Qt.Key_Up or  \
@@ -87,15 +90,29 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         """
         for item in self.items:
             item.initialize()
+        # initialize the projection matrix and model view matrix
+        self.projection_matrix = self.get_projection_matrix()
+        self.update_model_projection()
+        self.view_matrix = self.get_view_matrix()
+        self.update_model_view()
+
+    def set_view_matrix(self, view_matrix):
+        self.view_matrix = view_matrix
+        self.view_need_update = False
 
     def mouseReleaseEvent(self, ev):
         if hasattr(self, 'mousePos'):
             delattr(self, 'mousePos')
 
+    def set_dist(self, dist):
+        self.dist = dist
+        self.view_need_update = True
+
     def update_dist(self, delta):
         self.dist += delta
         if self.dist < 0.1:
             self.dist = 0.1
+        self.view_need_update = True
 
     def wheelEvent(self, ev):
         delta = ev.angleDelta().x()
@@ -121,17 +138,32 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
             dist = max(self.dist, 0.5)
             self.center += Rwc @ Kinv @ np.array([-diff.x(), diff.y(), 0]) * dist
         self.show_center = True
+        self.view_need_update = True
+
+    def set_center(self, center):
+        self.center = center
+        self.view_need_update = True
 
     def paintGL(self):
-        pass
-        self.update_model_projection()
+        # if the camera is moved, update the model view matrix.
+        if self.view_need_update:
+            self.view_matrix = self.get_view_matrix()
+            self.view_need_update = False
         self.update_model_view()
+
+        # set the background color
         bgcolor = self.color
         glClearColor(*bgcolor)
         glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT)
         for item in self.items:
             if not item.visible():
                 continue
+            if not item.is_initialized():
+                """
+                The item may not be initialized if it is added
+                after the widget is shown, so we need to initialize it here.
+                """
+                item.initialize()
             glMatrixMode(GL_MODELVIEW)
             glPushMatrix()
             glPushAttrib(GL_ALL_ATTRIB_BITS)
@@ -163,37 +195,46 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         # Handle rotation keys
         if QtCore.Qt.Key_Up in self.active_keys:
             self.rotate(radians(rot_speed), 0, 0)
+            self.view_need_update = True
         if QtCore.Qt.Key_Down in self.active_keys:
             self.rotate(radians(-rot_speed), 0, 0)
+            self.view_need_update = True
         if QtCore.Qt.Key_Left in self.active_keys:
             self.rotate(0, 0, radians(rot_speed))
+            self.view_need_update = True
         if QtCore.Qt.Key_Right in self.active_keys:
             self.rotate(0, 0, radians(-rot_speed))
+            self.view_need_update = True
         # Handle zoom keys
         xz_keys = {QtCore.Qt.Key_Z, QtCore.Qt.Key_X}
         if self.active_keys & xz_keys:
             Rwc = euler_to_matrix(self.euler)
             if QtCore.Qt.Key_Z in self.active_keys:
                 self.center += Rwc @ np.array([0, 0, -trans_speed])
+                self.view_need_update = True
             if QtCore.Qt.Key_X in self.active_keys:
                 self.center += Rwc @ np.array([0, 0, trans_speed])
+                self.view_need_update = True
         # Handle translation keys on the z plane
         dir_keys = {QtCore.Qt.Key_W, QtCore.Qt.Key_S, QtCore.Qt.Key_A, QtCore.Qt.Key_D}
         if self.active_keys & dir_keys:
             Rz = euler_to_matrix([0, 0, self.euler[2]])
             if QtCore.Qt.Key_W in self.active_keys:
                 self.center += Rz @ np.array([0, trans_speed, 0])
+                self.view_need_update = True
             if QtCore.Qt.Key_S in self.active_keys:
                 self.center += Rz @ np.array([0, -trans_speed, 0])
+                self.view_need_update = True
             if QtCore.Qt.Key_A in self.active_keys:
                 self.center += Rz @ np.array([-trans_speed, 0, 0])
+                self.view_need_update = True
             if QtCore.Qt.Key_D in self.active_keys:
                 self.center += Rz @ np.array([trans_speed, 0, 0])
+                self.view_need_update = True
 
     def update_model_view(self):
-        m = self.get_view_matrix()
         glMatrixMode(GL_MODELVIEW)
-        glLoadMatrixf(m.T)
+        glLoadMatrixf(self.view_matrix.T)
         
     def get_view_matrix(self):
         two = self.center # the origin(center) in the world frame
@@ -206,12 +247,19 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         return Tcw
 
     def set_cam_position(self, **kwargs):
-        pos = kwargs.get('pos', None)
+        center = kwargs.get('center', None)
         distance = kwargs.get('distance', None)
-        if pos is not None:
-            self.center = pos
+        euler = kwargs.get('euler', None)
+        if center is not None:
+            self.set_center(center)
         if distance is not None:
-            self.dist = distance
+            self.set_dist(distance)
+        if euler is not None:
+            self.set_euler(euler)
+    
+    def set_euler(self, euler):
+        self.euler = euler
+        self.view_need_update = True
 
     def set_color(self, color):
         self.color = color
@@ -221,9 +269,8 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         super().update()
 
     def update_model_projection(self):
-        m = self.get_projection_matrix()
         glMatrixMode(GL_PROJECTION)
-        glLoadMatrixf(m.T)
+        glLoadMatrixf(self.projection_matrix.T)
 
     def get_projection_matrix(self):
         w, h = self.current_width(), self.current_height()
@@ -259,3 +306,17 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
 
     def change_show_center(self, state):
         self.enable_show_center = state
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self.projection_matrix = self.get_projection_matrix()
+        self.update_model_projection()
+
+    def capture_frame(self):
+        self.makeCurrent()  # Ensure the OpenGL context is current
+        width = self.current_width()
+        height = self.current_height()
+        pixels = glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE)
+        frame = np.frombuffer(pixels, dtype=np.uint8).reshape(height, width, 3)
+        frame = np.flip(frame, 0)
+        return frame

{q3dviewer-1.0.7 → q3dviewer-1.1.1}/q3dviewer/base_item.py

@@ -16,6 +16,7 @@ class BaseItem(QtCore.QObject):
         self._glwidget = None
         self._visible = True
         self._initialized = False
+        self._disable_setting = False
         
     def set_glwidget(self, v):
         self._glwidget = v
@@ -38,6 +39,17 @@ class BaseItem(QtCore.QObject):
     def initialize(self):
         if not self._initialized:
             self.initialize_gl()
+            self._initialized = True
+
+    def is_initialized(self):
+        return self._initialized
+
+    def add_setting(self, layout):
+        """
+        Add setting widgets to the layout.
+        This method should be overridden by subclasses to add any necessary setting widgets to the layout.
+        """
+        pass
     
     def initialize_gl(self):
         """
@@ -53,5 +65,8 @@ class BaseItem(QtCore.QObject):
         """
         pass
 
+    def disable_setting(self):
+        self._disable_setting = True
+