q3dviewer 1.0.7__tar.gz

q3dviewer-1.0.7/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: q3dviewer
+Version: 1.0.7
+Summary: UNKNOWN
+Home-page: UNKNOWN
+Author: UNKNOWN
+Author-email: UNKNOWN
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN

q3dviewer-1.0.7/README.md

@@ -0,0 +1,164 @@
+## 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.
+
+## 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.
+
+## 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
+# Use the command below if the path is not set, though it's not recommended
+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:
+
+[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)
+
+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,.
+
+![Screenshot](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.
+
+```sh
+roscore &
+ros_viewer
+```
+
+### 3. Gaussian Viewer
+
+A simple viewer for 3D Gaussian.
+see: https://github.com/scomup/EasyGaussianSplatting
+
+
+```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)
+
+### 4. 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)
+
+### 5. 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**: 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
+
+### 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__()
+        pass  # 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):
+        pass  # Obtain the data you want to visualize
+
+    def initialize_gl(self):
+        pass  # OpenGL initialization settings (if needed)
+
+    def paint(self):
+        pass  # Visualize 3D objects using OpenGL
+```
+
+Enjoy using `q3dviewer`!

q3dviewer-1.0.7/q3dviewer/__init__.py

@@ -0,0 +1,5 @@
+from q3dviewer.custom_items import *
+from q3dviewer.glwidget import *
+from q3dviewer.viewer import *
+from q3dviewer.base_item import *
+from q3dviewer.base_glwidget import *

q3dviewer-1.0.7/q3dviewer/base_glwidget.py

@@ -0,0 +1,261 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+from OpenGL.GL import *
+from math import radians, tan
+import numpy as np
+from PySide6 import QtCore, QtGui, QtOpenGLWidgets
+from q3dviewer.utils.maths import frustum, euler_to_matrix, makeT
+
+
+class BaseGLWidget(QtOpenGLWidgets.QOpenGLWidget):
+    def __init__(self, parent=None):
+        QtOpenGLWidgets.QOpenGLWidget.__init__(self, parent)
+        self.setFocusPolicy(QtCore.Qt.FocusPolicy.ClickFocus)
+        self.reset()
+        self._fov = 60
+        self.items = []
+        self.keyTimer = QtCore.QTimer()
+        self.color = np.array([0, 0, 0, 0])
+        self.dist = 40
+        self.euler = np.array([np.pi/3, 0, np.pi/4])
+        self.center = np.array([0, 0, 0.])
+        self.active_keys = set()
+        self.show_center = False
+        self.enable_show_center = True
+
+    def keyPressEvent(self, ev: QtGui.QKeyEvent):
+        if ev.key() == QtCore.Qt.Key_Up or  \
+            ev.key() == QtCore.Qt.Key_Down or \
+            ev.key() == QtCore.Qt.Key_Left or \
+            ev.key() == QtCore.Qt.Key_Right or \
+            ev.key() == QtCore.Qt.Key_Z or \
+            ev.key() == QtCore.Qt.Key_X or \
+            ev.key() == QtCore.Qt.Key_A or \
+            ev.key() == QtCore.Qt.Key_D or \
+            ev.key() == QtCore.Qt.Key_W or \
+            ev.key() == QtCore.Qt.Key_S:
+            self.active_keys.add(ev.key())
+        self.active_keys.add(ev.key())
+
+    def keyReleaseEvent(self, ev: QtGui.QKeyEvent):
+        self.active_keys.discard(ev.key())
+
+    def current_width(self):
+        """
+        Return the current width of the widget.
+        """
+        return int(self.width() * self.devicePixelRatioF())
+
+    def current_height(self):
+        """
+        Return the current height of the widget.
+        """
+        return int(self.height() * self.devicePixelRatioF())
+
+    def reset(self):
+        pass
+
+    def add_item(self, item):
+        """
+        Add the item to the glwidget.
+        """
+        self.items.append(item)
+        item.set_glwidget(self)
+        
+    def remove_item(self, item):
+        """
+        Remove the item from the glwidget.
+        """
+        self.items.remove(item)
+        item.set_glwidget(None)
+
+    def clear(self):
+        """
+        Remove all items from the glwidget.
+        """
+        for item in self.items:
+            item.set_glwidget(None)
+        self.items = []
+        
+    def initializeGL(self):
+        """
+        the method is herted from QOpenGLWidget, 
+        and it is called when the widget is first shown.
+        """
+        for item in self.items:
+            item.initialize()
+
+    def mouseReleaseEvent(self, ev):
+        if hasattr(self, 'mousePos'):
+            delattr(self, 'mousePos')
+
+    def update_dist(self, delta):
+        self.dist += delta
+        if self.dist < 0.1:
+            self.dist = 0.1
+
+    def wheelEvent(self, ev):
+        delta = ev.angleDelta().x()
+        if delta == 0:
+            delta = ev.angleDelta().y()
+        self.update_dist(-delta * self.dist * 0.001)
+        self.show_center = True
+
+    def mouseMoveEvent(self, ev):
+        lpos = ev.localPos()
+        if not hasattr(self, 'mousePos'):
+            self.mousePos = lpos
+        diff = lpos - self.mousePos
+        self.mousePos = lpos
+        if ev.buttons() == QtCore.Qt.MouseButton.RightButton:
+            rot_speed = 0.2
+            dyaw = radians(-diff.x() * rot_speed)
+            droll = radians(-diff.y() * rot_speed)
+            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.show_center = True
+
+    def paintGL(self):
+        pass
+        self.update_model_projection()
+        self.update_model_view()
+        bgcolor = self.color
+        glClearColor(*bgcolor)
+        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT)
+        for item in self.items:
+            if not item.visible():
+                continue
+            glMatrixMode(GL_MODELVIEW)
+            glPushMatrix()
+            glPushAttrib(GL_ALL_ATTRIB_BITS)
+            try:
+                item.paint()
+            finally:
+                glPopAttrib()
+                glMatrixMode(GL_MODELVIEW)
+                glPopMatrix()
+        
+        # Show center as a point if updated by mouse move event
+        if self.enable_show_center and self.show_center:
+            point_size = np.clip((self.get_K()[0, 0] / self.dist), 10, 100)
+            glPointSize(point_size)
+            glBegin(GL_POINTS)
+            glColor3f(1.0, 0.0, 0.0)  # Red color for the center point
+            glVertex3f(*self.center)
+            glEnd()
+            self.show_center = False
+    
+    def update_movement(self):
+        """
+        Update the movement of the camera based on the active keys.
+        """
+        if not self.active_keys:
+            return
+        rot_speed = 0.5
+        trans_speed = max(self.dist * 0.005, 0.1)
+        # Handle rotation keys
+        if QtCore.Qt.Key_Up in self.active_keys:
+            self.rotate(radians(rot_speed), 0, 0)
+        if QtCore.Qt.Key_Down in self.active_keys:
+            self.rotate(radians(-rot_speed), 0, 0)
+        if QtCore.Qt.Key_Left in self.active_keys:
+            self.rotate(0, 0, radians(rot_speed))
+        if QtCore.Qt.Key_Right in self.active_keys:
+            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])
+            if QtCore.Qt.Key_X in self.active_keys:
+                self.center += 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])
+            if QtCore.Qt.Key_S in self.active_keys:
+                self.center += 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])
+            if QtCore.Qt.Key_D in self.active_keys:
+                self.center += Rz @ np.array([trans_speed, 0, 0])
+
+    def update_model_view(self):
+        m = self.get_view_matrix()
+        glMatrixMode(GL_MODELVIEW)
+        glLoadMatrixf(m.T)
+        
+    def get_view_matrix(self):
+        two = self.center # the origin(center) in the world frame
+        tco = np.array([0, 0, self.dist]) # the origin(center) in camera frame
+        Rwc = euler_to_matrix(self.euler)
+        twc = two + Rwc @ tco
+        Rcw = Rwc.T
+        tcw = -Rcw @ twc
+        Tcw = makeT(Rcw, tcw)
+        return Tcw
+
+    def set_cam_position(self, **kwargs):
+        pos = kwargs.get('pos', None)
+        distance = kwargs.get('distance', None)
+        if pos is not None:
+            self.center = pos
+        if distance is not None:
+            self.dist = distance
+
+    def set_color(self, color):
+        self.color = color
+
+    def update(self):
+        self.update_movement()
+        super().update()
+
+    def update_model_projection(self):
+        m = self.get_projection_matrix()
+        glMatrixMode(GL_PROJECTION)
+        glLoadMatrixf(m.T)
+
+    def get_projection_matrix(self):
+        w, h = self.current_width(), self.current_height()
+        dist = self.dist
+        near = dist * 0.001
+        far = dist * 10000.
+        r = near * tan(0.5 * radians(self._fov))
+        t = r * h / w
+        matrix = frustum(-r, r, -t, t, near, far)
+        return matrix
+
+    def get_K(self):
+        project_matrix = self.get_projection_matrix()
+        width = self.current_width()
+        height = self.current_height()
+        fx = project_matrix[0, 0] * width / 2
+        fy = project_matrix[1, 1] * height / 2
+        cx = width / 2
+        cy = height / 2
+        K = np.array([
+            [fx, 0, cx],
+            [0, fy, cy],
+            [0, 0, 1]
+        ])
+        return K
+            
+    def rotate(self, rx=0, ry=0, rz=0):
+        # update the euler angles
+        self.euler += np.array([rx, ry, rz])
+        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)
+
+    def change_show_center(self, state):
+        self.enable_show_center = state

q3dviewer-1.0.7/q3dviewer/base_item.py

@@ -0,0 +1,57 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+from PySide6 import QtCore
+import numpy as np
+
+class BaseItem(QtCore.QObject):
+    _next_id = 0
+    
+    def __init__(self):
+        super().__init__()
+        self._id = BaseItem._next_id
+        BaseItem._next_id += 1
+        self._glwidget = None
+        self._visible = True
+        self._initialized = False
+        
+    def set_glwidget(self, v):
+        self._glwidget = v
+        
+    def glwidget(self):
+        return self._glwidget
+    
+    def hide(self):
+        self._visible = False
+        
+    def show(self):
+        self._visible = True
+    
+    def set_visible(self, vis):
+        self._visible = vis
+        
+    def visible(self):
+        return self._visible
+    
+    def initialize(self):
+        if not self._initialized:
+            self.initialize_gl()
+    
+    def initialize_gl(self):
+        """
+        Initialize OpenGL resources for the item.
+        This method should be overridden by subclasses to set up any necessary OpenGL resources.
+        """
+        pass
+
+    def paint(self):
+        """
+        Render the item using OpenGL.
+        This method should be overridden by subclasses to perform the actual rendering.
+        """
+        pass
+
+
+

q3dviewer-1.0.7/q3dviewer/custom_items/__init__.py

@@ -0,0 +1,9 @@
+from q3dviewer.custom_items.axis_item import *
+from q3dviewer.custom_items.cloud_item import *
+from q3dviewer.custom_items.cloud_io_item import *
+from q3dviewer.custom_items.gaussian_item import *
+from q3dviewer.custom_items.frame_item import *
+from q3dviewer.custom_items.grid_item import *
+from q3dviewer.custom_items.text_item import *
+from q3dviewer.custom_items.image_item import *
+from q3dviewer.custom_items.line_item import *

q3dviewer-1.0.7/q3dviewer/custom_items/axis_item.py

@@ -0,0 +1,148 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+from q3dviewer.base_item import BaseItem
+from q3dviewer.utils import set_uniform
+from OpenGL.GL import *
+import numpy as np
+from OpenGL.GL import shaders
+from PySide6.QtWidgets import QLabel, QDoubleSpinBox
+
+
+# Vertex and Fragment shader source code
+vertex_shader_source = """
+#version 330 core
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec3 color;
+
+out vec3 ourColor;
+
+uniform mat4 view_matrix;
+uniform mat4 project_matrix;
+uniform mat4 model_matrix;
+uniform float size;
+
+void main()
+{
+    vec3 scaled_position = position * size;
+    gl_Position = project_matrix * view_matrix * model_matrix * vec4(scaled_position, 1.0);
+    ourColor = color;
+}
+"""
+
+fragment_shader_source = """
+#version 330 core
+in vec3 ourColor;
+out vec4 color;
+
+void main()
+{
+    color = vec4(ourColor, 1.0);
+}
+"""
+
+
+class AxisItem(BaseItem):
+    def __init__(self, size=1.0, width=2):
+        super().__init__()
+        self.size = size
+        self.width = width
+        self.model_matrix = np.eye(4, dtype=np.float32)
+        self.need_update_setting = True
+
+    def initialize_gl(self):
+        # Axis vertices and colors
+        self.vertices = np.array([
+            # positions         # colors
+            [0.0, 0.0, 0.0,    1.0, 0.0, 0.0],  # X axis (red)
+            [1.0, 0.0, 0.0,    1.0, 0.0, 0.0],
+            [0.0, 0.0, 0.0,    0.0, 1.0, 0.0],  # Y axis (green)
+            [0.0, 1.0, 0.0,    0.0, 1.0, 0.0],
+            [0.0, 0.0, 0.0,    0.0, 0.0, 1.0],  # Z axis (blue)
+            [0.0, 0.0, 1.0,    0.0, 0.0, 1.0],
+        ], dtype=np.float32)
+
+        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)
+
+        # Vertex positions
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 24, ctypes.c_void_p(0))
+        glEnableVertexAttribArray(0)
+
+        # Vertex colors
+        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 24, ctypes.c_void_p(12))
+        glEnableVertexAttribArray(1)
+
+        # Compile shaders and create shader program
+        self.program = shaders.compileProgram(
+            shaders.compileShader(vertex_shader_source, GL_VERTEX_SHADER),
+            shaders.compileShader(fragment_shader_source, GL_FRAGMENT_SHADER),
+        )
+
+        glBindVertexArray(0)
+
+    def add_setting(self, layout):
+        label_size = QLabel("Set size:")
+        layout.addWidget(label_size)
+        spinbox_size = QDoubleSpinBox()
+        spinbox_size.setSingleStep(0.1)
+        layout.addWidget(spinbox_size)
+        spinbox_size.setValue(self.size)
+        spinbox_size.valueChanged.connect(self.set_size)
+        spinbox_size.setRange(0.0, 100)
+
+        label_width = QLabel("Set width:")
+        layout.addWidget(label_width)
+        spinbox_width = QDoubleSpinBox()
+        layout.addWidget(spinbox_width)
+        spinbox_width.setSingleStep(0.1)
+        spinbox_width.setValue(self.width)
+        spinbox_width.valueChanged.connect(self.set_width)
+        spinbox_width.setRange(0, 1000)
+
+    def set_size(self, size):
+        self.size = size
+        self.need_update_setting = True
+
+    def update_setting(self):
+        if not self.need_update_setting:
+            return
+        glUseProgram(self.program)
+        set_uniform(self.program, float(self.size), 'size')
+        set_uniform(self.program, self.model_matrix, 'model_matrix')
+        glUseProgram(0)
+        self.need_update_setting = False
+
+    def set_width(self, width):
+        self.width = width
+        
+    def set_transform(self, transform):
+        """
+        Set the transformation matrix for the axis item.
+        """
+        self.model_matrix = transform
+        self.need_update_setting = True
+
+    def paint(self):
+        self.update_setting()
+        glLineWidth(self.width)
+        glUseProgram(self.program)
+        glBindVertexArray(self.vao)
+
+        view_matrix = self.glwidget().get_view_matrix()
+        project_matrix = self.glwidget().get_projection_matrix()
+        set_uniform(self.program, view_matrix, 'view_matrix')
+        set_uniform(self.program, project_matrix, 'project_matrix')
+
+        glDrawArrays(GL_LINES, 0, 6)
+
+        glBindVertexArray(0)
+        glUseProgram(0)
+        glLineWidth(1)