q3dviewer 1.1.2__tar.gz → 1.1.4__tar.gz

{q3dviewer-1.1.2/q3dviewer.egg-info → q3dviewer-1.1.4}/PKG-INFO

@@ -1,14 +1,22 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.1.2
+Version: 1.1.4
 Summary: A library designed for quickly deploying a 3D viewer.
 Home-page: https://github.com/scomup/q3dviewer
 Author: Liu Yang
 License: UNKNOWN
-Description: ## q3dviewer
+Description: 
+        ![q3dviewer Logo](imgs/logo.png)
+        
+        [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+        [![PyPI version](https://badge.fury.io/py/q3dviewer.svg)](https://badge.fury.io/py/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.
         
+        
+        To show how to use `q3dviewer` as a library, we also provide some [very useful tools](#tools).
+        
+        
         ## Installation
         
         To install `q3dviewer`, execute the following command in your terminal on either Linux or Windows:
@@ -37,10 +45,10 @@ Description: ## q3dviewer
         
         ### 1. Cloud Viewer
         
-        A tool for visualizing point cloud files. Launch it by executing the following command in your terminal:
+        A tool for visualizing point cloud files (LAS, PCD, PLY, E57). Launch it by executing the following command in your terminal:
         
         ```sh
-        cloud_viewer  # The viewer will be displayed
+        cloud_viewer
         ```
         
         *Alternatively*, if the path is not set (though it's not recommended):
@@ -49,7 +57,13 @@ Description: ## q3dviewer
         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.
+        **Basic Operations**
+        * Load files: Drag and drop point cloud files onto the window (multiple files are OK).
+        * `M` key: Display the visualization settings screen for point clouds, background color, etc.
+        * `Left mouse button` & `W, A, S, D` keys: Move the viewpoint on the horizontal plane.
+        * `Z, X` keys: Move in the direction the screen is facing.
+        * `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the screen center unchanged.
+        * `Shift` + `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the camera position unchanged.
         
         For example, you can download and view point clouds of Tokyo in LAS format from the following link:
         
@@ -75,15 +89,21 @@ Description: ## q3dviewer
         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
+        film_maker
         ```
         
+        **Basic Operations**
+        * File loading & viewpoint movement: Same as Cloud_Viewer
         * Space key to add a keyframe.
         * Delete key to remove a keyframe.
+        * Play button: Automatically play the video (pressing again will stop playback)
+        * Record checkbox: When checked, actions will be automatically recorded during playback
         
         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)
+        ![film_maker_demo.gif](imgs/film_maker_demo.gif)
+        
+        The demo video demonstrating how to use Film Maker utilizes the [cloud data of Kyobashi Station Area](https://www.geospatial.jp/ckan/dataset/kyoubasiekisyuuhen_las) located in Osaka, Japan.
         
         ### 4. Gaussian Viewer
         

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/README.md

@@ -1,7 +1,15 @@
-## q3dviewer
+
+![q3dviewer Logo](imgs/logo.png)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://badge.fury.io/py/q3dviewer.svg)](https://badge.fury.io/py/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.
 
+
+To show how to use `q3dviewer` as a library, we also provide some [very useful tools](#tools).
+
+
 ## Installation
 
 To install `q3dviewer`, execute the following command in your terminal on either Linux or Windows:
@@ -30,10 +38,10 @@ 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:
+A tool for visualizing point cloud files (LAS, PCD, PLY, E57). Launch it by executing the following command in your terminal:
 
 ```sh
-cloud_viewer  # The viewer will be displayed
+cloud_viewer
 ```
 
 *Alternatively*, if the path is not set (though it's not recommended):
@@ -42,7 +50,13 @@ cloud_viewer  # The viewer will be displayed
 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.
+**Basic Operations**
+* Load files: Drag and drop point cloud files onto the window (multiple files are OK).
+* `M` key: Display the visualization settings screen for point clouds, background color, etc.
+* `Left mouse button` & `W, A, S, D` keys: Move the viewpoint on the horizontal plane.
+* `Z, X` keys: Move in the direction the screen is facing.
+* `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the screen center unchanged.
+* `Shift` + `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the camera position unchanged.
 
 For example, you can download and view point clouds of Tokyo in LAS format from the following link:
 
@@ -68,15 +82,21 @@ ros_viewer
 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
+film_maker
 ```
 
+**Basic Operations**
+* File loading & viewpoint movement: Same as Cloud_Viewer
 * Space key to add a keyframe.
 * Delete key to remove a keyframe.
+* Play button: Automatically play the video (pressing again will stop playback)
+* Record checkbox: When checked, actions will be automatically recorded during playback
 
 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)
+![film_maker_demo.gif](imgs/film_maker_demo.gif)
+
+The demo video demonstrating how to use Film Maker utilizes the [cloud data of Kyobashi Station Area](https://www.geospatial.jp/ckan/dataset/kyoubasiekisyuuhen_las) located in Osaka, Japan.
 
 ### 4. Gaussian Viewer
 

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/pyproject.toml

@@ -9,12 +9,12 @@ 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"
+matplotlib = "^3.4"
 
 [tool.poetry.scripts]
 cloud_viewer = "q3dviewer.tools.cloud_viewer:main"

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/base_glwidget.py

@@ -25,7 +25,7 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         self.active_keys = set()
         self.show_center = False
         self.enable_show_center = True
-        self.view_need_update = True
+        self.need_recalc_view = True
         self.view_matrix = self.get_view_matrix()
         self.projection_matrix = self.get_projection_matrix()
 
@@ -98,7 +98,7 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
 
     def set_view_matrix(self, view_matrix):
         self.view_matrix = view_matrix
-        self.view_need_update = False
+        self.need_recalc_view = False
 
     def mouseReleaseEvent(self, ev):
         if hasattr(self, 'mousePos'):
@@ -106,13 +106,13 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
 
     def set_dist(self, dist):
         self.dist = dist
-        self.view_need_update = True
+        self.need_recalc_view = True
 
     def update_dist(self, delta):
         self.dist += delta
         if self.dist < 0.1:
             self.dist = 0.1
-        self.view_need_update = True
+        self.need_recalc_view = True
 
     def wheelEvent(self, ev):
         delta = ev.angleDelta().x()
@@ -121,6 +121,24 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         self.update_dist(-delta * self.dist * 0.001)
         self.show_center = True
 
+
+    def rotate_keep_cam_pos(self, rx=0, ry=0, rz=0):
+        """
+        Rotate the camera while keeping the current camera position. 
+        This updates both the Euler angles and the center point.
+        """
+        new_euler = self.euler + np.array([rx, ry, rz])
+        new_euler = (new_euler + np.pi) % (2 * np.pi) - np.pi
+        
+        Rwc_old = euler_to_matrix(self.euler)
+        tco = np.array([0, 0, self.dist])
+        twc = self.center + Rwc_old @ tco
+        
+        Rwc_new = euler_to_matrix(new_euler)
+        self.center = twc - Rwc_new @ tco
+        self.euler = new_euler
+        self.need_recalc_view = True
+
     def mouseMoveEvent(self, ev):
         lpos = ev.localPos()
         if not hasattr(self, 'mousePos'):
@@ -131,24 +149,26 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
             rot_speed = 0.2
             dyaw = radians(-diff.x() * rot_speed)
             droll = radians(-diff.y() * rot_speed)
-            self.rotate(droll, 0, dyaw)
+            if ev.modifiers() & QtCore.Qt.ShiftModifier:
+                self.rotate_keep_cam_pos(droll, 0, dyaw)
+            else:
+                self.rotate(droll, 0, dyaw)
         elif ev.buttons() == QtCore.Qt.MouseButton.LeftButton:
             Rwc = euler_to_matrix(self.euler)
             Kinv = np.linalg.inv(self.get_K())
             dist = max(self.dist, 0.5)
-            self.center += Rwc @ Kinv @ np.array([-diff.x(), diff.y(), 0]) * dist
+            self.translate(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
+        self.need_recalc_view = True
 
     def paintGL(self):
         # if the camera is moved, update the model view matrix.
-        if self.view_need_update:
+        if self.need_recalc_view:
             self.view_matrix = self.get_view_matrix()
-            self.view_need_update = False
+            self.need_recalc_view = False
         self.update_model_view()
 
         # set the background color
@@ -192,45 +212,48 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
             return
         rot_speed = 0.5
         trans_speed = max(self.dist * 0.005, 0.1)
+        shift_pressed = QtCore.Qt.Key_Shift in self.active_keys
         # 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 shift_pressed:
+                self.rotate_keep_cam_pos(radians(rot_speed), 0, 0)
+            else:
+                self.rotate(radians(rot_speed), 0, 0)
         if QtCore.Qt.Key_Down in self.active_keys:
-            self.rotate(radians(-rot_speed), 0, 0)
-            self.view_need_update = True
+            if shift_pressed:
+                self.rotate_keep_cam_pos(radians(-rot_speed), 0, 0)
+            else:
+                self.rotate(radians(-rot_speed), 0, 0)
         if QtCore.Qt.Key_Left in self.active_keys:
-            self.rotate(0, 0, radians(rot_speed))
-            self.view_need_update = True
+            if shift_pressed:
+                self.rotate_keep_cam_pos(0, 0, radians(rot_speed))
+            else:
+                self.rotate(0, 0, radians(rot_speed))
         if QtCore.Qt.Key_Right in self.active_keys:
-            self.rotate(0, 0, radians(-rot_speed))
-            self.view_need_update = True
+            if shift_pressed:
+                self.rotate_keep_cam_pos(0, 0, radians(-rot_speed))
+            else:
+                self.rotate(0, 0, radians(-rot_speed))
         # 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
+                self.translate(Rwc @ np.array([0, 0, -trans_speed]))
             if QtCore.Qt.Key_X in self.active_keys:
-                self.center += Rwc @ np.array([0, 0, trans_speed])
-                self.view_need_update = True
+                self.translate(Rwc @ np.array([0, 0, trans_speed]))
         # 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
+                self.translate(Rz @ np.array([0, trans_speed, 0]))
             if QtCore.Qt.Key_S in self.active_keys:
-                self.center += Rz @ np.array([0, -trans_speed, 0])
-                self.view_need_update = True
+                self.translate(Rz @ np.array([0, -trans_speed, 0]))
             if QtCore.Qt.Key_A in self.active_keys:
-                self.center += Rz @ np.array([-trans_speed, 0, 0])
-                self.view_need_update = True
+                self.translate(Rz @ np.array([-trans_speed, 0, 0]))
             if QtCore.Qt.Key_D in self.active_keys:
-                self.center += Rz @ np.array([trans_speed, 0, 0])
-                self.view_need_update = True
+                self.translate(Rz @ np.array([trans_speed, 0, 0]))
 
     def update_model_view(self):
         glMatrixMode(GL_MODELVIEW)
@@ -259,7 +282,7 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
     
     def set_euler(self, euler):
         self.euler = euler
-        self.view_need_update = True
+        self.need_recalc_view = True
 
     def set_color(self, color):
         self.color = color
@@ -303,6 +326,11 @@ class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
         self.euler[2] = (self.euler[2] + np.pi) % (2 * np.pi) - np.pi
         self.euler[1] = (self.euler[1] + np.pi) % (2 * np.pi) - np.pi
         self.euler[0] = np.clip(self.euler[0], 0, np.pi)
+        self.need_recalc_view = True
+
+    def translate(self, trans):
+        self.center += trans
+        self.need_recalc_view = True
 
     def change_show_center(self, state):
         self.enable_show_center = state

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/custom_items/cloud_io_item.py

@@ -61,18 +61,28 @@ class CloudIOItem(CloudItem):
     def load(self, file, append=False):
         # print("Try to load %s ..." % file)
         if file.endswith(".pcd"):
-            cloud, color_mode = load_pcd(file)
+            cloud = load_pcd(file)
         elif file.endswith(".ply"):
-            cloud, color_mode = load_ply(file)
+            cloud = load_ply(file)
         elif file.endswith(".e57"):
-            cloud, color_mode = load_e57(file)
+            cloud = load_e57(file)
         elif file.endswith(".las"):
-            cloud, color_mode = load_las(file)
+            cloud = load_las(file)
         else:
             print("Not supported file type.")
             return
         self.set_data(data=cloud, append=append)
-        self.set_color_mode(color_mode)
+
+        has_intensity = cloud['irgb'][0] & 0xff000000 > 0
+        has_rgb = cloud['irgb'][0] & 0x00ffffff > 0
+
+        if has_rgb:
+            self.set_color_mode('RGB')
+        elif has_intensity:
+            self.set_color_mode('I')
+        else:
+            self.set_color_mode('FLAT')
+
         return cloud
 
     def set_path(self, path):

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/custom_items/cloud_item.py

@@ -14,15 +14,13 @@ from PySide6.QtWidgets import QLabel, QLineEdit, QDoubleSpinBox, \
 from OpenGL.GL import shaders
 from q3dviewer.utils import *
 from q3dviewer.utils.range_slider import RangeSlider
-from PySide6.QtCore import QRegularExpression
-from PySide6.QtGui import QRegularExpressionValidator
 
 
 # draw points with color (x, y, z, color)
 class CloudItem(BaseItem):
     def __init__(self, size, alpha, 
                  color_mode='I', 
-                 color='#ffffff', 
+                 color='white', 
                  point_type='PIXEL', 
                  depth_test=False):
         super().__init__()
@@ -34,7 +32,12 @@ class CloudItem(BaseItem):
         self.point_type = point_type
         self.mutex = threading.Lock()
         self.data_type = [('xyz', '<f4', (3,)), ('irgb', '<u4')]
-        self.flat_rgb = int(color[1:], 16)
+        self.color = color
+        try:
+            self.flat_rgb = text_to_rgba(color, flat=True)
+        except ValueError:
+            print(f"Invalid color: {color}, please use matplotlib color format")
+            exit(1)
         self.mode_table = {'FLAT': 0,  'I': 1,  'RGB': 2}
         self.point_type_table = {'PIXEL': 0, 'SQUARE': 1, 'SPHERE': 2}
         self.color_mode = self.mode_table[color_mode]
@@ -89,14 +92,12 @@ class CloudItem(BaseItem):
         layout.addWidget(self.combo_color)
 
         label_rgb = QLabel("Color:")
+        label_rgb.setToolTip("Use hex color, i.e. #FF4500, or named color, i.e. 'red'")
         layout.addWidget(label_rgb)
         self.edit_rgb = QLineEdit()
-        self.edit_rgb.setToolTip("Hex number, i.e. #FF4500")
-        self.edit_rgb.setText(f"#{self.flat_rgb:06x}")
+        self.edit_rgb.setToolTip("Use hex color, i.e. #FF4500, or named color, i.e. 'red'")
+        self.edit_rgb.setText(self.color)
         self.edit_rgb.textChanged.connect(self._on_color)
-        regex = QRegularExpression(r"^#[0-9A-Fa-f]{6}$")
-        validator = QRegularExpressionValidator(regex)
-        self.edit_rgb.setValidator(validator)
         layout.addWidget(self.edit_rgb)
 
         self.slider_v = RangeSlider()
@@ -108,6 +109,7 @@ class CloudItem(BaseItem):
             "Show front points first (Depth Test)")
         self.checkbox_depth_test.setChecked(self.depth_test)
         self.checkbox_depth_test.stateChanged.connect(self.set_depthtest)
+        self._on_color_mode(self.color_mode)
         layout.addWidget(self.checkbox_depth_test)
 
     def _on_range(self, lower, upper):
@@ -164,11 +166,10 @@ class CloudItem(BaseItem):
 
     def _on_color(self, color):
         try:
-            flat_rgb = int(color[1:], 16)
-            self.flat_rgb = flat_rgb
+            self.flat_rgb = text_to_rgba(color, flat=True)
             self.need_update_setting = True
         except ValueError:
-            pass
+            print(f"Invalid color: {color}, please use matplotlib color format")
 
     def set_size(self, size):
         self.size = size

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/custom_items/frame_item.py

@@ -162,13 +162,9 @@ class FrameItem(BaseItem):
             self.need_updating = False
         
     def set_color(self, color):
-        if isinstance(color, str):
-            self.rgba = hex_to_rgba(color)
-        elif isinstance(color, list):
-            self.rgba = color
-        elif isinstance(color, tuple):
-            self.rgba = list(color)
-        else:
+        try:
+            self.rgba = text_to_rgba(color)
+        except ValueError:
             raise ValueError("Invalid color format")
 
     def set_line_width(self, width):

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/custom_items/grid_item.py

@@ -6,10 +6,8 @@ Distributed under MIT license. See LICENSE for more information.
 from q3dviewer.base_item import BaseItem
 from OpenGL.GL import *
 from PySide6.QtWidgets import QLabel, QDoubleSpinBox, QLineEdit
-from PySide6.QtCore import QRegularExpression
-from PySide6.QtGui import QRegularExpressionValidator
 import numpy as np
-from q3dviewer.utils.maths import hex_to_rgba
+from q3dviewer.utils.maths import text_to_rgba
 
 
 class GridItem(BaseItem):
@@ -24,9 +22,9 @@ class GridItem(BaseItem):
 
     def set_color(self, color):
         try:
-            self.rgba = hex_to_rgba(color)
+            self.rgba = text_to_rgba(color)
         except ValueError:
-            pass
+            raise ValueError("Invalid color format. Use hex format like '#RRGGBB' or '#RRGGBBAA'.")
 
     def generate_grid_vertices(self):
         vertices = []
@@ -41,16 +39,13 @@ class GridItem(BaseItem):
     def initialize_gl(self):
         self.vao = glGenVertexArrays(1)
         vbo = glGenBuffers(1)
-
         glBindVertexArray(self.vao)
-
         glBindBuffer(GL_ARRAY_BUFFER, vbo)
         glBufferData(GL_ARRAY_BUFFER, self.vertices.nbytes, self.vertices, GL_STATIC_DRAW)
-
         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0))
         glEnableVertexAttribArray(0)
-
         glBindVertexArray(0)
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
 
     def add_setting(self, layout):
         spinbox_size = QDoubleSpinBox()
@@ -73,6 +68,7 @@ class GridItem(BaseItem):
         spinbox_offset_x.setPrefix("Offset X: ")
         spinbox_offset_x.setSingleStep(0.1)
         spinbox_offset_x.setValue(self.offset[0])
+        spinbox_offset_x.setRange(-1000, 1000)
         spinbox_offset_x.valueChanged.connect(self._on_offset_x)
         layout.addWidget(spinbox_offset_x)
         
@@ -80,6 +76,7 @@ class GridItem(BaseItem):
         spinbox_offset_y.setPrefix("Offset Y: ")
         spinbox_offset_y.setSingleStep(0.1)
         spinbox_offset_y.setValue(self.offset[1])
+        spinbox_offset_y.setRange(-1000, 1000)
         spinbox_offset_y.valueChanged.connect(self._on_offset_y)
         layout.addWidget(spinbox_offset_y)
         
@@ -87,6 +84,7 @@ class GridItem(BaseItem):
         spinbox_offset_z.setPrefix("Offset Z: ")
         spinbox_offset_z.setSingleStep(0.1)
         spinbox_offset_z.setValue(self.offset[2])
+        spinbox_offset_z.setRange(-1000, 1000)
         spinbox_offset_z.valueChanged.connect(self._on_offset_z)
         layout.addWidget(spinbox_offset_z)
 

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/custom_items/image_item.py

@@ -7,7 +7,6 @@ from q3dviewer.base_item import BaseItem
 from OpenGL.GL import *
 import numpy as np
 from OpenGL.GL import shaders
-from PIL import Image as PIL_Image
 from PySide6.QtWidgets import QLabel, QSpinBox, QCheckBox
 
 
@@ -108,12 +107,8 @@ class ImageItem(BaseItem):
         glBindVertexArray(0)
 
     def set_data(self, data):
-        if isinstance(data, np.ndarray):
-            pass
-        elif isinstance(data, PIL_Image.Image):
-            data = np.array(data)
-        else:
-            print("not support image type")
+        if not isinstance(data, np.ndarray):
+            print("The image type is not supported.")
             raise NotImplementedError
 
         if data.ndim == 2:  # Grayscale image

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/custom_items/line_item.py

@@ -8,13 +8,16 @@ from OpenGL.GL import *
 import numpy as np
 import threading
 from PySide6.QtWidgets import QLabel, QLineEdit, QDoubleSpinBox
-from PySide6.QtCore import QRegularExpression
-from PySide6.QtGui import QRegularExpressionValidator
-from q3dviewer.utils.maths import hex_to_rgba
+from q3dviewer.utils.maths import text_to_rgba
 
 
 class LineItem(BaseItem):
     def __init__(self, width=1, color='#00ff00', line_type='LINE_STRIP'):
+        """
+        line_type: 'LINE_STRIP' or 'LINES'
+          LINE_STRIP: draw a connected line strip
+          LINES: draw a series of unconnected lines
+        """
         super(LineItem, self).__init__()
         self.width = width
         self.buff = np.empty((0, 3), np.float32)
@@ -23,19 +26,20 @@ class LineItem(BaseItem):
         self.capacity = 100000
         self.valid_buff_top = 0
         self.color = color
-        self.rgb = hex_to_rgba(color)
+        try:
+            self.rgb = text_to_rgba(color)
+        except ValueError:
+            raise ValueError("Invalid color format. Use mathplotlib color format.")
+
         self.line_type = GL_LINE_STRIP if line_type == 'LINE_STRIP' else GL_LINES
 
     def add_setting(self, layout):
         label_color = QLabel("Color:")
         layout.addWidget(label_color)
         self.color_edit = QLineEdit()
-        self.color_edit.setToolTip("Hex number, i.e. #FF4500")
+        self.color_edit.setToolTip("mathplotlib color format")
         self.color_edit.setText(self.color)
         self.color_edit.textChanged.connect(self._on_color)
-        regex = QRegularExpression(r"^#[0-9A-Fa-f]{6}$")
-        validator = QRegularExpressionValidator(regex)
-        self.color_edit.setValidator(validator)
         layout.addWidget(self.color_edit)
 
         spinbox_width = QDoubleSpinBox()
@@ -48,10 +52,10 @@ class LineItem(BaseItem):
 
     def _on_color(self, color):
         try:
-            self.rgb = hex_to_rgba(color)
+            self.rgb = text_to_rgba(color)
             self.color = color
         except ValueError:
-            pass
+            print("Invalid color format. Use mathplotlib color format.")
 
     def set_color(self, color):
         self.color_edit.setText(color)

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/custom_items/text_item.py

@@ -6,7 +6,7 @@ Distributed under MIT license. See LICENSE for more information.
 from PySide6 import QtCore, QtGui
 from q3dviewer.base_item import BaseItem
 from OpenGL.GL import *
-from q3dviewer.utils.maths import hex_to_rgba
+from q3dviewer.utils.maths import text_to_rgba
 
 
 class Text2DItem(BaseItem):
@@ -16,8 +16,10 @@ class Text2DItem(BaseItem):
         """All keyword arguments are passed to set_data()"""
         BaseItem.__init__(self)
         self.pos = (20, 50)
-        self.color = '#ffffff'
-        self.rgb = hex_to_rgba(self.color)
+        try:
+            self.rgb = text_to_rgba(self.color)
+        except ValueError:
+            raise ValueError("Invalid color format. Use mathplotlib color format.")
         self.text = ''
         self.font = QtGui.QFont('Helvetica', 16)
         self.set_data(**kwds)
@@ -44,10 +46,10 @@ class Text2DItem(BaseItem):
 
     def set_color(self, color):
         try:
-            self.rgb = hex_to_rgba(color)
+            self.rgb = text_to_rgba(color)
             self.color = color
         except ValueError:
-            pass
+            print("Invalid color format. Use mathplotlib color format.")
 
     def paint(self):
         if len(self.text) < 1:

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/glwidget.py

@@ -5,11 +5,11 @@ Distributed under MIT license. See LICENSE for more information.
 
 from PySide6 import QtCore
 from PySide6.QtWidgets import QWidget, QComboBox, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QCheckBox, QGroupBox
-from PySide6.QtGui import QKeyEvent, QVector3D, QRegularExpressionValidator
-from PySide6.QtCore import QRegularExpression
+from PySide6.QtGui import QKeyEvent, QVector3D
 from OpenGL.GL import *
 import numpy as np
 from q3dviewer.base_glwidget import BaseGLWidget
+from q3dviewer.utils.maths import text_to_rgba
 
 class SettingWindow(QWidget):
     def __init__(self):
@@ -52,7 +52,7 @@ class GLWidget(BaseGLWidget):
     def __init__(self):
         self.followed_name = 'none'
         self.named_items = {}
-        self.color_str = '#000000'
+        self.color_str = 'black'
         self.followable_item_name = None
         self.setting_window = SettingWindow()
         self.enable_show_center = True
@@ -80,9 +80,6 @@ class GLWidget(BaseGLWidget):
         color_edit.setToolTip("'using hex color, i.e. #FF4500")
         color_edit.setText(self.color_str)
         color_edit.textChanged.connect(self.set_bg_color)
-        regex = QRegularExpression(r"^#[0-9A-Fa-f]{6}$")
-        validator = QRegularExpressionValidator(regex)
-        color_edit.setValidator(validator)
         layout.addWidget(color_edit)
         
         label_focus = QLabel("Set Focus:")
@@ -108,16 +105,13 @@ class GLWidget(BaseGLWidget):
             if item.__class__.__name__ == 'AxisItem' and not item._disable_setting:
                 self.followable_item_name.append(name)
 
-    def set_bg_color(self, color_str):
+    def set_bg_color(self, color):
         try:
-            color_flat = int(color_str[1:], 16)
-            red = (color_flat >> 16) & 0xFF
-            green = (color_flat >> 8) & 0xFF
-            blue = color_flat & 0xFF
-            self.color_str = color_str
-            self.set_color([red, green, blue, 0])
+            self.color_str = color
+            red, green, blue, alpha = text_to_rgba(color)
+            self.set_color([red, green, blue, alpha])
         except ValueError:
-            return
+            print("Invalid color format. Use mathplotlib color format.")
 
     def add_item_with_name(self, name, item):
         self.named_items.update({name: item})

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/tools/film_maker.py

@@ -151,7 +151,6 @@ class CMMViewer(q3d.Viewer):
         main_layout.addWidget(dock_widget)
         self.dock = dock_widget
 
-
     def update_video_path(self, path):
         self.video_path = path
 
@@ -235,7 +234,6 @@ class CMMViewer(q3d.Viewer):
         self.glwidget.set_cam_position(center=center,
                                        euler=euler)
 
-
     def create_frames(self):
         """
         Create the frames for playback by interpolating between key frames.

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/utils/cloud_io.py

@@ -24,17 +24,14 @@ def load_ply(file):
     xyz = mesh.points
     rgb = np.zeros([xyz.shape[0]], dtype=np.uint32)
     intensity = np.zeros([xyz.shape[0]], dtype=np.uint32)
-    color_mode = 'FLAT'
     if "intensity" in mesh.point_data:
         intensity = mesh.point_data["intensity"]
-        color_mode = 'I'
     if "rgb" in mesh.point_data:
         rgb = mesh.point_data["rgb"]
-        color_mode = 'RGB'
     irgb = (intensity << 24) | rgb
     dtype = [('xyz', '<f4', (3,)), ('irgb', '<u4')]
     cloud = np.rec.fromarrays([xyz, irgb], dtype=dtype)
-    return cloud, color_mode
+    return cloud
 
 
 def save_pcd(cloud, save_path):
@@ -51,8 +48,35 @@ def save_pcd(cloud, save_path):
     i = (cloud['irgb'] & 0xFF000000) >> 24
     rgb = cloud['irgb'] & 0x00FFFFFF
 
-    dtype = [('xyz', '<f4', (3,)), ('intensity', '<u4'), ('rgb', '<u4')]
-    tmp = np.rec.fromarrays([cloud['xyz'], i, rgb], dtype=dtype)
+    # check no rgb value
+    if np.max(rgb) == 0:
+        fields = ('x', 'y', 'z', 'intensity')
+        metadata = MetaData.model_validate(
+            {
+                "fields": fields,
+                "size": [4, 4, 4, 4],
+                "type": ['F', 'F', 'F', 'U'],
+                "count": [1, 1, 1, 1],
+                "width": cloud.shape[0],
+                "points": cloud.shape[0],
+            })
+
+        dtype = [('xyz', '<f4', (3,)), ('intensity', '<u4')]
+        tmp = np.rec.fromarrays([cloud['xyz'], i], dtype=dtype)
+        PointCloud(metadata, tmp).save(save_path)
+    else:
+        fields = ('x', 'y', 'z', 'intensity', 'rgb')
+        metadata = MetaData.model_validate(
+        {
+            "fields": fields,
+            "size": [4, 4, 4, 4, 4],
+            "type": ['F', 'F', 'F', 'U', 'U'],
+            "count": [1, 1, 1, 1, 1],
+            "width": cloud.shape[0],
+            "points": cloud.shape[0],
+        })
+        dtype = [('xyz', '<f4', (3,)), ('intensity', '<u4'), ('rgb', '<u4')]
+        tmp = np.rec.fromarrays([cloud['xyz'], i, rgb], dtype=dtype)
 
     PointCloud(metadata, tmp).save(save_path)
 
@@ -62,17 +86,14 @@ def load_pcd(file):
     pc = PointCloud.from_path(file).pc_data
     rgb = np.zeros([pc.shape[0]], dtype=np.uint32)
     intensity = np.zeros([pc.shape[0]], dtype=np.uint32)
-    color_mode = 'FLAT'
     if 'intensity' in pc.dtype.names:
         intensity = pc['intensity'].astype(np.uint32)
-        color_mode = 'I'
     if 'rgb' in pc.dtype.names:
         rgb = pc['rgb'].astype(np.uint32)
-        color_mode = 'RGB'
     irgb = (intensity << 24) | rgb
     xyz = np.stack([pc['x'], pc['y'], pc['z']], axis=1)
     cloud = np.rec.fromarrays([xyz, irgb], dtype=dtype)
-    return cloud, color_mode
+    return cloud
 
 
 def save_e57(cloud, save_path):
@@ -100,23 +121,20 @@ def load_e57(file_path):
     z = scans["cartesianZ"]
     rgb = np.zeros([x.shape[0]], dtype=np.uint32)
     intensity = np.zeros([x.shape[0]], dtype=np.uint32)
-    color_mode = 'FLAT'
     if "intensity" in scans:
         intensity = scans["intensity"].astype(np.uint32)
-        color_mode = 'I'
     if all([x in scans for x in ["colorRed", "colorGreen", "colorBlue"]]):
         r = scans["colorRed"].astype(np.uint32)
         g = scans["colorGreen"].astype(np.uint32)
         b = scans["colorBlue"].astype(np.uint32)
         rgb = (r << 16) | (g << 8) | b
-        color_mode = 'RGB'
     irgb = (intensity << 24) | rgb
     dtype = [('xyz', '<f4', (3,)), ('irgb', '<u4')]
     cloud = np.rec.fromarrays(
         [np.stack([x, y, z], axis=1), irgb],
         dtype=dtype)
     e57.close()
-    return cloud, color_mode
+    return cloud
 
 
 def load_las(file):
@@ -124,27 +142,24 @@ def load_las(file):
         las = f.read()
         xyz = np.vstack((las.x, las.y, las.z)).transpose()
         dimensions = list(las.point_format.dimension_names)
-        color_mode = 'FLAT'
         rgb = np.zeros([las.x.shape[0]], dtype=np.uint32)
         intensity = np.zeros([las.x.shape[0]], dtype=np.uint32)
         if 'intensity' in dimensions:
             intensity = las.intensity.astype(np.uint32)
-            color_mode = 'I'
         if 'red' in dimensions and 'green' in dimensions and 'blue' in dimensions:
             red = las.red
             green = las.green
             blue = las.blue
             max_val = np.max([red, green, blue])
             if red.dtype == np.dtype('uint16') and max_val > 255:
-                red = (red / 65535.0 * 255).astype(np.uint32)
-                green = (green / 65535.0 * 255).astype(np.uint32)
-                blue = (blue / 65535.0 * 255).astype(np.uint32)
+                red = (red / 255).astype(np.uint32)
+                green = (green / 255).astype(np.uint32)
+                blue = (blue / 255).astype(np.uint32)
             rgb = (red << 16) | (green << 8) | blue
-            color_mode = 'RGB'
-        color = (intensity << 24) | rgb
+        color = ((intensity / 255)<< 24) | rgb
         dtype = [('xyz', '<f4', (3,)), ('irgb', '<u4')]
         cloud = np.rec.fromarrays([xyz, color], dtype=dtype)
-    return cloud, color_mode
+    return cloud
 
 def save_las(cloud, save_path):
     header = laspy.LasHeader(point_format=3, version="1.2")
@@ -152,10 +167,10 @@ def save_las(cloud, save_path):
     las.x = cloud['xyz'][:, 0]
     las.y = cloud['xyz'][:, 1]
     las.z = cloud['xyz'][:, 2]
-    las.red = (cloud['irgb'] >> 16) & 0xFF
-    las.green = (cloud['irgb'] >> 8) & 0xFF
-    las.blue = cloud['irgb'] & 0xFF
-    las.intensity = cloud['irgb'] >> 24
+    las.red = ((cloud['irgb'] >> 16) & 0xFF) * 255
+    las.green = ((cloud['irgb'] >> 8) & 0xFF) * 255
+    las.blue = (cloud['irgb'] & 0xFF)
+    las.intensity = (cloud['irgb'] >> 24) * 255
     las.write(save_path)
 
 

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer/utils/maths.py

@@ -10,6 +10,7 @@ https://github.com/scomup/MathematicalRobotics.git
 
 
 import numpy as np
+from matplotlib.colors import to_rgba
 
 
 _epsilon_ = 1e-5
@@ -292,26 +293,27 @@ def makeRt(T):
     t = T[0:3, 3]
     return R, t
 
-def hex_to_rgba(hex_color):
-    if not hex_color.startswith("#"):
-        print("Invalid hex color string.")
-        return (1.0, 1.0, 1.0, 1.0)
-    if len(hex_color) == 7:
-        color_flat = int(hex_color[1:], 16)
-        red = (color_flat >> 16) & 0xFF
-        green = (color_flat >> 8) & 0xFF
-        blue = color_flat & 0xFF
-        return (red / 255.0, green / 255.0, blue / 255.0, 1.0)
-    elif len(hex_color) == 9:
-        color_flat = int(hex_color[1:], 16)
-        red = (color_flat >> 24) & 0xFF
-        green = (color_flat >> 16) & 0xFF
-        blue = (color_flat >> 8) & 0xFF
-        alpha = color_flat & 0xFF
-        return (red / 255.0, green / 255.0, blue / 255.0, alpha / 255.0)
+
+def text_to_rgba(color_text, flat=False):
+    """
+    Convert a color text to an RGBA tuple.
+    
+    :param color_text: e.g. '#FF0000', '#FF0000FF', 'red', 'green', 'blue', 'yellow', 
+                       'black', 'white', 'magenta', 'cyan', 'r', 'g', 'b', 'y', 'k', 'w', 'm', 'c'
+    :return: RGBA tuple, e.g. (1.0, 0.0, 0.0, 1.0)
+    """
+    rgba = to_rgba(color_text)
+    if flat:
+        r, g, b, _ = (np.array(rgba)*255).astype(np.uint32)
+        falt_rgb = ((r << 16) & 0xFF0000) | \
+                   ((g << 8) & 0x00FF00) | \
+                   ((b << 0) & 0x0000FF)
+        return falt_rgb
     else:
-        print("Invalid hex color string.")
-        return (1.0, 1.0, 1.0, 1.0)
+        return rgba
+    # except ValueError as e:
+    #     raise ValueError(f"Invalid color text '{color_text}': {e}")
+
 
 # euler = np.array([1, 0.1, 0.1])
 # euler_angles = matrix_to_euler(euler_to_matrix(euler))

{q3dviewer-1.1.2 → q3dviewer-1.1.4/q3dviewer.egg-info}/PKG-INFO

@@ -1,14 +1,22 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.1.2
+Version: 1.1.4
 Summary: A library designed for quickly deploying a 3D viewer.
 Home-page: https://github.com/scomup/q3dviewer
 Author: Liu Yang
 License: UNKNOWN
-Description: ## q3dviewer
+Description: 
+        ![q3dviewer Logo](imgs/logo.png)
+        
+        [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+        [![PyPI version](https://badge.fury.io/py/q3dviewer.svg)](https://badge.fury.io/py/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.
         
+        
+        To show how to use `q3dviewer` as a library, we also provide some [very useful tools](#tools).
+        
+        
         ## Installation
         
         To install `q3dviewer`, execute the following command in your terminal on either Linux or Windows:
@@ -37,10 +45,10 @@ Description: ## q3dviewer
         
         ### 1. Cloud Viewer
         
-        A tool for visualizing point cloud files. Launch it by executing the following command in your terminal:
+        A tool for visualizing point cloud files (LAS, PCD, PLY, E57). Launch it by executing the following command in your terminal:
         
         ```sh
-        cloud_viewer  # The viewer will be displayed
+        cloud_viewer
         ```
         
         *Alternatively*, if the path is not set (though it's not recommended):
@@ -49,7 +57,13 @@ Description: ## q3dviewer
         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.
+        **Basic Operations**
+        * Load files: Drag and drop point cloud files onto the window (multiple files are OK).
+        * `M` key: Display the visualization settings screen for point clouds, background color, etc.
+        * `Left mouse button` & `W, A, S, D` keys: Move the viewpoint on the horizontal plane.
+        * `Z, X` keys: Move in the direction the screen is facing.
+        * `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the screen center unchanged.
+        * `Shift` + `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the camera position unchanged.
         
         For example, you can download and view point clouds of Tokyo in LAS format from the following link:
         
@@ -75,15 +89,21 @@ Description: ## q3dviewer
         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
+        film_maker
         ```
         
+        **Basic Operations**
+        * File loading & viewpoint movement: Same as Cloud_Viewer
         * Space key to add a keyframe.
         * Delete key to remove a keyframe.
+        * Play button: Automatically play the video (pressing again will stop playback)
+        * Record checkbox: When checked, actions will be automatically recorded during playback
         
         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)
+        ![film_maker_demo.gif](imgs/film_maker_demo.gif)
+        
+        The demo video demonstrating how to use Film Maker utilizes the [cloud data of Kyobashi Station Area](https://www.geospatial.jp/ckan/dataset/kyoubasiekisyuuhen_las) located in Osaka, Japan.
         
         ### 4. Gaussian Viewer
         

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/q3dviewer.egg-info/requires.txt

@@ -2,9 +2,9 @@ PyOpenGL
 imageio
 imageio[ffmpeg]
 laspy
+matplotlib
 meshio
 numpy
-pillow
 pye57
 pypcd4
 pyside6

{q3dviewer-1.1.2 → q3dviewer-1.1.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='q3dviewer',
-    version='1.1.2',
+    version='1.1.4',
     author="Liu Yang",
     description="A library designed for quickly deploying a 3D viewer.",
     long_description=open("README.md").read(),
@@ -22,13 +22,13 @@ setup(
         'numpy',
         'pyside6',
         'PyOpenGL',
-        'pillow',
         'meshio',
         'pypcd4',
         'pye57',
         'laspy',
         'imageio',
         'imageio[ffmpeg]',
+        'matplotlib',
     ],
     entry_points={
         'console_scripts': [