q3dviewer 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

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/base_glwidget.py

@@ -0,0 +1,256 @@
+"""
+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):
+        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)
+            item.paint()
+            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):
+        twc = self.center
+        tcw = np.array([0, 0, self.dist])
+        Rwc = euler_to_matrix(self.euler)
+        twc = twc + Rwc @ tcw
+        Twc = makeT(Rwc, twc)
+        return np.linalg.inv(Twc)
+
+    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/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/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/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)

q3dviewer/custom_items/cloud_io_item.py

@@ -0,0 +1,79 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+from q3dviewer.custom_items.cloud_item import CloudItem
+from pathlib import Path
+import os
+from PySide6.QtWidgets import QPushButton, QLabel, QLineEdit, QMessageBox
+from q3dviewer.utils.cloud_io import save_pcd, save_ply, save_e57, save_las, load_pcd, load_ply, load_e57, load_las
+
+class CloudIOItem(CloudItem):
+    """
+    add save/load function to CloudItem
+    """
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.save_path = str(Path(os.path.expanduser("~"), "data.pcd"))
+
+    def add_setting(self, layout):
+        super().add_setting(layout)
+
+        label4 = QLabel("Save Path:")
+        layout.addWidget(label4)
+        box4 = QLineEdit()
+        box4.setText(self.save_path)
+        box4.textChanged.connect(self.set_path)
+        layout.addWidget(box4)
+        save_button = QPushButton("Save Cloud")
+        save_button.clicked.connect(self.save)
+        layout.addWidget(save_button)
+        self.save_msg = QMessageBox()
+        self.save_msg.setIcon(QMessageBox.Information)
+        self.save_msg.setWindowTitle("save")
+        self.save_msg.setStandardButtons(QMessageBox.Ok)
+
+    def save(self):
+        cloud = self.buff[:self.valid_buff_top]
+        func = None
+        if self.save_path.endswith(".pcd"):
+            func = save_pcd
+        elif self.save_path.endswith(".ply"):
+            func = save_ply
+        elif self.save_path.endswith(".e57"):
+            func = save_e57
+        elif self.save_path.endswith(".las"):
+            func = save_las
+        elif self.save_path.endswith(".tif") or self.save_path.endswith(".tiff"):
+            print("Do not support save as tif type!")
+        else:
+            print("Unsupported cloud file type!")
+        try:
+            func(cloud, self.save_path)
+            self.save_msg.setText("Save cloud to  %s" % self.save_path)
+        except Exception as e:
+            print(e)
+            self.save_msg.setText("Cannot save to %s" % self.save_path)
+            self.save_msg.exec()
+        self.save_msg.exec()
+
+    def load(self, file, append=False):
+        # print("Try to load %s ..." % file)
+        if file.endswith(".pcd"):
+            cloud, color_mode = load_pcd(file)
+        elif file.endswith(".ply"):
+            cloud, color_mode = load_ply(file)
+        elif file.endswith(".e57"):
+            cloud, color_mode = load_e57(file)
+        elif file.endswith(".las"):
+            cloud, color_mode = load_las(file)
+        else:
+            print("Not supported file type.")
+            return
+        self.set_data(data=cloud, append=append)
+        self.set_color_mode(color_mode)
+        return cloud
+
+    def set_path(self, path):
+        self.save_path = path