q3dviewer 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

q3dviewer/.vscode/c_cpp_properties.json

@@ -0,0 +1,30 @@
+{
+  "configurations": [
+    {
+      "browse": {
+        "databaseFilename": "${default}",
+        "limitSymbolsToIncludedHeaders": false
+      },
+      "includePath": [
+        "/home/liu/catkin_ws/devel/include/**",
+        "/opt/ros/noetic/include/**",
+        "/home/liu/catkin_ws/src/marker_test/apriltag_ros/apriltag_ros/include/**",
+        "/home/liu/catkin_ws/src/BALM/include/**",
+        "/home/liu/catkin_ws/src/FAST-LIVO/include/**",
+        "/home/liu/catkin_ws/src/grid2dlib/include/**",
+        "/home/liu/catkin_ws/src/lidar_cam_calib/include/**",
+        "/home/liu/catkin_ws/src/livox_laser_simulation/include/**",
+        "/home/liu/catkin_ws/src/usb_cam/include/**",
+        "/home/liu/catkin_ws/src/rpg_vikit/vikit_common/include/**",
+        "/home/liu/catkin_ws/src/rpg_vikit/vikit_ros/include/**",
+        "/usr/include/**"
+      ],
+      "name": "ROS",
+      "intelliSenseMode": "gcc-x64",
+      "compilerPath": "/usr/bin/gcc",
+      "cStandard": "gnu11",
+      "cppStandard": "c++14"
+    }
+  ],
+  "version": 4
+}

q3dviewer/.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "python.autoComplete.extraPaths": [
+        "/home/liu/catkin_ws/devel/lib/python3/dist-packages",
+        "/opt/ros/noetic/lib/python3/dist-packages"
+    ],
+    "python.analysis.extraPaths": [
+        "/home/liu/catkin_ws/devel/lib/python3/dist-packages",
+        "/opt/ros/noetic/lib/python3/dist-packages"
+    ]
+}

q3dviewer/base_glwidget.py

@@ -89,6 +89,9 @@ class BaseGLWidget(QOpenGLWidget):
         the method is herted from QOpenGLWidget, 
         and it is called when the widget is first shown.
         """
+        glEnable(GL_DEPTH_TEST)
+        glDepthFunc(GL_LESS)
+        
         for item in self.items:
             item.initialize()
         # initialize the projection matrix and model view matrix
@@ -302,7 +305,7 @@ class BaseGLWidget(QOpenGLWidget):
         near = dist * 0.001
         far = dist * 10000.
         r = near * tan(0.5 * radians(self._fov))
-        t = r * h / w
+        t = r * h / max(w, 1)
         matrix = frustum(-r, r, -t, t, near, far)
         return matrix
 
@@ -349,3 +352,55 @@ class BaseGLWidget(QOpenGLWidget):
         frame = np.frombuffer(pixels, dtype=np.uint8).reshape(height, width, 3)
         frame = np.flip(frame, 0)
         return frame
+    
+    def depth_to_meters(self, depth_buffer):
+        """
+        Convert normalized depth buffer values [0,1] to actual distances in meters.
+        
+        Args:
+            depth_buffer: numpy array with depth values in range [0,1]
+            
+        Returns:
+            numpy array with distances in meters
+        """
+        # Get near and far clipping planes
+        near = self.dist * 0.001
+        far = self.dist * 10000.
+        
+        # Convert from normalized depth [0,1] to linear depth in meters
+        # OpenGL depth buffer formula: depth = (1/z - 1/near) / (1/far - 1/near)
+        # Solving for z: z = 1 / (depth * (1/far - 1/near) + 1/near)
+        
+        # Avoid division by zero for depth = 1.0 (far plane)
+        depth_clamped = np.clip(depth_buffer, 0.0, 0.999999)
+        
+        linear_depth = 1.0 / (depth_clamped * (1.0/far - 1.0/near) + 1.0/near)
+        
+        return linear_depth
+
+
+    def get_point(self, x, y):
+        self.makeCurrent()  # Ensure the OpenGL context is current
+        width = self.current_width()
+        height = self.current_height()  
+
+        gl_y = height - y - 1
+        z = glReadPixels(x, gl_y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT)
+        z = np.frombuffer(z, dtype=np.float32)[0]
+        if z == 1.0 or z == 0.0:
+            return None 
+
+        # Retrieve OpenGL matrices (column-major), convert to numpy arrays and transpose
+        view = np.array(glGetFloatv(GL_MODELVIEW_MATRIX), dtype=np.float32).reshape((4,4)).T
+        proj = np.array(glGetFloatv(GL_PROJECTION_MATRIX), dtype=np.float32).reshape((4,4)).T   
+
+        # Convert screen (x, y, z) to normalized device coordinates (NDC)
+        ndc_x = (x / width) * 2.0 - 1.0
+        ndc_y = (gl_y / height) * 2.0 - 1.0
+        ndc_z = 2.0 * z - 1.0
+        ndc = np.array([ndc_x, ndc_y, ndc_z, 1.0], dtype=np.float32)    
+
+        inv_projview = np.linalg.inv(proj @ view)
+        world_p = inv_projview @ ndc
+        world_p /= world_p[3]
+        return world_p[:3]

q3dviewer/custom_items/__init__.py

@@ -7,3 +7,4 @@ from q3dviewer.custom_items.grid_item import GridItem
 from q3dviewer.custom_items.text_item import Text2DItem
 from q3dviewer.custom_items.image_item import ImageItem
 from q3dviewer.custom_items.line_item import LineItem
+from q3dviewer.custom_items.text3d_item import Text3DItem

q3dviewer/custom_items/cloud_io_item.py

@@ -11,7 +11,22 @@ from q3dviewer.utils.cloud_io import save_pcd, save_ply, save_e57, save_las, loa
 
 class CloudIOItem(CloudItem):
     """
-    add save/load function to CloudItem
+    A OpenGL point cloud item with input/output capabilities.
+    Attributes:
+        size (float): The size of each point. When `point_type` is 'PIXEL', this is the size in screen pixels.
+            When `point_type` is 'SQUARE' or 'SPHERE', this is the size in centimeters in 3D space.
+        alpha (float): The transparency of the points, in the range [0, 1], where 0 is fully transparent and 1 is fully opaque.
+        color_mode (str): The coloring mode for the points.
+            - 'FLAT': Single flat color for all points (uses the `color` attribute).
+            - 'I': Color by intensity.
+            - 'RGB': Per-point RGB color.
+            - 'GRAY': Per-point grayscale color.
+        color (str or tuple): The flat color to use when `color_mode` is 'FLAT'. Accepts any valid matplotlib color (e.g., 'red', '#FF4500', (1.0, 0.5, 0.0)).
+        point_type (str): The type/rendering style of each point:
+            - 'PIXEL': Draw each point as a square pixel on the screen.
+            - 'SQUARE': Draw each point as a square in 3D space.
+            - 'SPHERE': Draw each point as a sphere in 3D space.
+        depth_test (bool): Whether to enable depth testing. If True, points closer to the camera will appear in front of farther ones.
     """
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

q3dviewer/custom_items/cloud_item.py

@@ -11,7 +11,7 @@ from OpenGL.GL import shaders
 
 import threading
 import os
-from q3dviewer.Qt.QtWidgets import QLabel, QLineEdit, QDoubleSpinBox, QComboBox, QCheckBox
+from q3dviewer.Qt.QtWidgets import QLabel, QLineEdit, QDoubleSpinBox, QSpinBox, QComboBox, QCheckBox
 from q3dviewer.utils.range_slider import RangeSlider
 from q3dviewer.utils import set_uniform
 from q3dviewer.utils import text_to_rgba
@@ -20,6 +20,25 @@ from q3dviewer.Qt import Q3D_DEBUG
 
 # draw points with color (x, y, z, color)
 class CloudItem(BaseItem):
+    """
+    A OpenGL point cloud item.
+
+    Attributes:
+        size (float): The size of each point. When `point_type` is 'PIXEL', this is the size in screen pixels.
+            When `point_type` is 'SQUARE' or 'SPHERE', this is the size in centimeters in 3D space.
+        alpha (float): The transparency of the points, in the range [0, 1], where 0 is fully transparent and 1 is fully opaque.
+        color_mode (str): The coloring mode for the points.
+            - 'FLAT': Single flat color for all points (uses the `color` attribute).
+            - 'I': Color by intensity.
+            - 'RGB': Per-point RGB color.
+            - 'GRAY': Per-point grayscale color.
+        color (str or tuple): The flat color to use when `color_mode` is 'FLAT'. Accepts any valid matplotlib color (e.g., 'red', '#FF4500', (1.0, 0.5, 0.0)).
+        point_type (str): The type/rendering style of each point:
+            - 'PIXEL': Draw each point as a square pixel on the screen.
+            - 'SQUARE': Draw each point as a square in 3D space.
+            - 'SPHERE': Draw each point as a sphere in 3D space.
+        depth_test (bool): Whether to enable depth testing. If True, points closer to the camera will appear in front of farther ones.
+    """
     def __init__(self, size, alpha, 
                  color_mode='I', 
                  color='white', 
@@ -40,7 +59,7 @@ class CloudItem(BaseItem):
         except ValueError:
             print(f"Invalid color: {color}, please use matplotlib color format")
             exit(1)
-        self.mode_table = {'FLAT': 0,  'I': 1,  'RGB': 2}
+        self.mode_table = {'FLAT': 0,  'I': 1,  'RGB': 2, 'GRAY': 3}
         self.point_type_table = {'PIXEL': 0, 'SQUARE': 1, 'SPHERE': 2}
         self.color_mode = self.mode_table[color_mode]
         self.CAPACITY = 10000000  # 10MB * 3 (x,y,z, color) * 4
@@ -65,11 +84,10 @@ class CloudItem(BaseItem):
         combo_ptype.currentIndexChanged.connect(self._on_point_type_selection)
         layout.addWidget(combo_ptype)
 
-        self.box_size = QDoubleSpinBox()
+        self.box_size = QSpinBox()
         self.box_size.setPrefix("Size: ")
         self.box_size.setSingleStep(1)
-        self.box_size.setDecimals(0)
-        self.box_size.setValue(self.size)
+        self.box_size.setValue(int(self.size))
         self.box_size.setRange(0, 100)
         self.box_size.valueChanged.connect(self.set_size)
         self._on_point_type_selection(self.point_type_table[self.point_type])
@@ -89,6 +107,7 @@ class CloudItem(BaseItem):
         self.combo_color.addItem("flat color")
         self.combo_color.addItem("intensity")
         self.combo_color.addItem("RGB")
+        self.combo_color.addItem("gray")
         self.combo_color.setCurrentIndex(self.color_mode)
         self.combo_color.currentIndexChanged.connect(self._on_color_mode)
         layout.addWidget(self.combo_color)
@@ -127,10 +146,13 @@ class CloudItem(BaseItem):
             self.edit_rgb.show()
         elif (index == self.mode_table['I']):  # flat color
             self.slider_v.show()
+        elif (index == self.mode_table['GRAY']):  # flat color
+            self.slider_v.show()
+
         self.need_update_setting = True
 
     def set_color_mode(self, color_mode):
-        if color_mode in {'FLAT', 'RGB', 'I'}:
+        if color_mode in {'FLAT', 'RGB', 'I', 'GRAY'}:
             try:
                 self.combo_color.setCurrentIndex(self.mode_table[color_mode])
             except:
@@ -143,17 +165,10 @@ class CloudItem(BaseItem):
         self.point_type = list(self.point_type_table.keys())[index]
         if self.point_type == 'PIXEL':
             self.box_size.setPrefix("Set size (pixel): ")
-            self.box_size.setDecimals(0)
-            self.box_size.setSingleStep(1)
-            self.size = np.ceil(self.size)
-            self.box_size.setValue(self.size)
         else:
-            self.box_size.setPrefix("Set size (meter): ")
-            self.box_size.setDecimals(2)
-            self.box_size.setSingleStep(0.01)
-            if self.size >= 1:
-                self.size = self.size * 0.01
-            self.box_size.setValue(self.size)
+            self.box_size.setPrefix("Set size (cm): ")
+        # self.size = 1
+        # self.box_size.setValue(self.size)
         self.need_update_setting = True
 
     def set_alpha(self, alpha):
@@ -222,7 +237,7 @@ class CloudItem(BaseItem):
         set_uniform(self.program, float(self.vmax), 'vmax')
         set_uniform(self.program, float(self.vmin), 'vmin')
         set_uniform(self.program, float(self.alpha), 'alpha')
-        set_uniform(self.program, float(self.size), 'point_size')
+        set_uniform(self.program, int(self.size), 'point_size')
         set_uniform(self.program, int(self.point_type_table[self.point_type]), 'point_type')
         glUseProgram(0)
         self.need_update_setting = False
@@ -292,10 +307,12 @@ class CloudItem(BaseItem):
         glEnable(GL_BLEND)
         glEnable(GL_PROGRAM_POINT_SIZE)
         glEnable(GL_POINT_SPRITE)
-        if self.depth_test:
-            glEnable(GL_DEPTH_TEST)
+        glEnable(GL_DEPTH_TEST)
+        
+        if not self.depth_test:
+            glDepthFunc(GL_ALWAYS)  # Always pass depth test but still write depth
         else:
-            glDisable(GL_DEPTH_TEST)
+            glDepthFunc(GL_LESS)    # Normal depth testing
 
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
         glUseProgram(self.program)
@@ -325,5 +342,3 @@ class CloudItem(BaseItem):
         glDisable(GL_POINT_SPRITE)
         glDisable(GL_PROGRAM_POINT_SIZE)
         glDisable(GL_BLEND)
-        if self.depth_test:
-            glDisable(GL_DEPTH_TEST)  # Disable depth testing if it was enabled

q3dviewer/custom_items/text3d_item.py

@@ -0,0 +1,120 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+
+from turtle import position
+from q3dviewer.base_item import BaseItem
+from OpenGL.GL import *
+from OpenGL.GLUT import glutBitmapCharacter, glutInit
+from OpenGL.GLUT import (
+    GLUT_BITMAP_HELVETICA_10,
+    GLUT_BITMAP_HELVETICA_12,
+    GLUT_BITMAP_HELVETICA_18,
+    # GLUT_BITMAP_TIMES_ROMAN_10,
+    GLUT_BITMAP_TIMES_ROMAN_24,
+)
+
+def get_glut_font(font_size):
+    # Map requested font_size to a GLUT font object
+    if font_size <= 10:
+        return GLUT_BITMAP_HELVETICA_10
+    elif font_size <= 12:
+        return GLUT_BITMAP_HELVETICA_12
+    elif font_size <= 18:
+        return GLUT_BITMAP_HELVETICA_18
+    elif font_size <= 24:
+        return GLUT_BITMAP_TIMES_ROMAN_24
+    else:
+        return GLUT_BITMAP_TIMES_ROMAN_24  # Largest available
+    
+
+# draw points with color (x, y, z, color)
+class Text3DItem(BaseItem):
+    """
+    A OpenGL 3d text and mark item.
+
+    Attributes:
+        data: list storing text data. Each element is a dict with keys:
+            'text': str, the text to display
+            'position': (x, y, z), the 3D position of the text
+            'color': (r, g, b, a), the color of the text
+            'font_size': float, the font size of the text
+            'point_size': float, size of point to draw at position (0 for no point)
+            'line_width': float, width of line to draw between points (0 for no line)
+
+    """
+    def __init__(self, data=[]):
+        super().__init__()
+        self._disable_setting = True
+        self.data_list = data # map of {'text': str, 'position': (x,y,z), 'color': (r,g,b,a), 'size': float}
+
+    def add_setting(self, layout):
+        pass # No settings for Text3DItem
+
+    def set_data(self, data, append=False):
+        if not append:
+            self.data_list = []
+        self.data_list.extend(data)
+
+    def clear_data(self):
+        self.data_list = []
+
+
+    def initialize_gl(self):
+        glutInit()
+        # super().initialize_gl()
+
+
+    def paint(self):
+        for item in self.data_list:
+            # Handle both dictionary and string formats
+            if isinstance(item, dict):
+                text = item.get('text', '')
+                pos = item.get('position', (0.0, 0.0, 0.0))
+                font_size = item.get('font_size', 24)
+                color = item.get('color', (1.0, 1.0, 1.0, 1.0))
+                point_size = item.get('point_size', 0.0)
+            elif isinstance(item, str):
+                # If item is a string, treat it as text with default position and color
+                text = item
+                pos = (0.0, 0.0, 0.0)
+                color = (1.0, 1.0, 1.0, 1.0)
+                font_size = 24
+                point_size = 0.0
+            else:
+                print(f"Warning: Unsupported item type: {type(item)}")
+                continue
+
+            glColor4f(*color)
+            offset = 0.02
+            pos_text = (pos[0] + offset, pos[1]+ offset, pos[2]+ offset)
+            glRasterPos3f(*pos_text)
+
+            if point_size > 0.0:
+                # draw a point at the position
+                glPointSize(point_size)
+                glBegin(GL_POINTS)
+                glVertex3f(*pos)
+                glEnd()
+            font = get_glut_font(font_size)
+            for ch in text:
+                glutBitmapCharacter(font, ord(ch))
+
+        # draw lines between points
+        for i in range(len(self.data_list) - 1):
+            item1 = self.data_list[i]
+            item2 = self.data_list[i + 1]
+            if isinstance(item1, dict) and isinstance(item2, dict):
+                pos1 = item1.get('position', (0.0, 0.0, 0.0))
+                pos2 = item2.get('position', (0.0, 0.0, 0.0))
+                line_width = item1.get('line_width', 0.0)
+                color = item1.get('color', (1.0, 1.0, 1.0, 1.0))
+                if line_width > 0.0:
+                    glColor4f(*color)
+                    glLineWidth(line_width)
+                    glBegin(GL_LINES)
+                    glVertex3f(*pos1)
+                    glVertex3f(*pos2)
+                    glEnd()

q3dviewer/custom_items/text_item.py

@@ -9,7 +9,16 @@ from q3dviewer.utils import text_to_rgba
 
 
 class Text2DItem(BaseItem):
-    """Draws text over opengl 3D."""
+    """
+    A OpenGL 2D text item.
+
+    Attributes:
+        pos: (x, y), the 2D position of the text in pixels
+        text: str, the text to display
+        font: QFont, the font of the text
+        color: str, the color of the text in matplotlib format
+        size: int, the font size of the text
+    """
 
     def __init__(self, **kwds):
         """All keyword arguments are passed to set_data()"""
@@ -17,11 +26,17 @@ class Text2DItem(BaseItem):
         self.pos = (20, 50)
         self.text = ''
         self.font = QtGui.QFont('Helvetica', 16)
-
-        self.rgb = text_to_rgba('w')
+        self.rgb = text_to_rgba('white')
         if 'pos' in kwds:
             self.pos = kwds['pos']
-        self.set_data(**kwds)
+        if 'text' in kwds:
+            self.text = kwds['text']
+        if 'font' in kwds:
+            self.font = kwds['font']
+        if 'color' in kwds:
+            self.set_color(kwds['color'])
+        if 'size' in kwds:
+            self.font.setPointSize(kwds['size'])
 
     def set_data(self, **kwds):
         args = ['pos', 'color', 'text', 'size', 'font']

q3dviewer/gau_io.py

@@ -1,168 +0,0 @@
-import numpy as np
-from plyfile import PlyData
-
-
-def gsdata_type(sh_dim):
-    return [('pw', '<f4', (3,)),
-            ('rot', '<f4', (4,)),
-            ('scale', '<f4', (3,)),
-            ('alpha', '<f4'),
-            ('sh', '<f4', (sh_dim))]
-
-
-def matrix_to_quaternion(matrices):
-    m00, m01, m02 = matrices[:, 0, 0], matrices[:, 0, 1], matrices[:, 0, 2]
-    m10, m11, m12 = matrices[:, 1, 0], matrices[:, 1, 1], matrices[:, 1, 2]
-    m20, m21, m22 = matrices[:, 2, 0], matrices[:, 2, 1], matrices[:, 2, 2]
-    t = 1 + m00 + m11 + m22
-    s = np.ones_like(m00)
-    w = np.ones_like(m00)
-    x = np.ones_like(m00)
-    y = np.ones_like(m00)
-    z = np.ones_like(m00)
-
-    t_positive = t > 0.0000001
-    s[t_positive] = 0.5 / np.sqrt(t[t_positive])
-    w[t_positive] = 0.25 / s[t_positive]
-    x[t_positive] = (m21[t_positive] - m12[t_positive]) * s[t_positive]
-    y[t_positive] = (m02[t_positive] - m20[t_positive]) * s[t_positive]
-    z[t_positive] = (m10[t_positive] - m01[t_positive]) * s[t_positive]
-
-    c1 = np.logical_and(m00 > m11, m00 > m22)
-    cond1 = np.logical_and(np.logical_not(t_positive), np.logical_and(m00 > m11, m00 > m22))
-
-    s[cond1] = 2.0 * np.sqrt(1.0 + m00[cond1] - m11[cond1] - m22[cond1])
-    w[cond1] = (m21[cond1] - m12[cond1]) / s[cond1]
-    x[cond1] = 0.25 * s[cond1]
-    y[cond1] = (m01[cond1] + m10[cond1]) / s[cond1]
-    z[cond1] = (m02[cond1] + m20[cond1]) / s[cond1]
-
-    c2 = np.logical_and(np.logical_not(c1), m11 > m22)
-    cond2 = np.logical_and(np.logical_not(t_positive), c2)
-    s[cond2] = 2.0 * np.sqrt(1.0 + m11[cond2] - m00[cond2] - m22[cond2])
-    w[cond2] = (m02[cond2] - m20[cond2]) / s[cond2]
-    x[cond2] = (m01[cond2] + m10[cond2]) / s[cond2]
-    y[cond2] = 0.25 * s[cond2]
-    z[cond2] = (m12[cond2] + m21[cond2]) / s[cond2]
-
-    c3 = np.logical_and(np.logical_not(c1), np.logical_not(c2))
-    cond3 = np.logical_and(np.logical_not(t_positive), c3)
-    s[cond3] = 2.0 * np.sqrt(1.0 + m22[cond3] - m00[cond3] - m11[cond3])
-    w[cond3] = (m10[cond3] - m01[cond3]) / s[cond3]
-    x[cond3] = (m02[cond3] + m20[cond3]) / s[cond3]
-    y[cond3] = (m12[cond3] + m21[cond3]) / s[cond3]
-    z[cond3] = 0.25 * s[cond3]
-    return np.array([w, x, y, z]).T
-
-
-def load_ply(path, T=None):
-    plydata = PlyData.read(path)
-    pws = np.stack((np.asarray(plydata.elements[0]["x"]),
-                    np.asarray(plydata.elements[0]["y"]),
-                    np.asarray(plydata.elements[0]["z"])),  axis=1)
-
-    alphas = np.asarray(plydata.elements[0]["opacity"])
-    alphas = 1/(1 + np.exp(-alphas))
-
-    scales = np.stack((np.asarray(plydata.elements[0]["scale_0"]),
-                       np.asarray(plydata.elements[0]["scale_1"]),
-                       np.asarray(plydata.elements[0]["scale_2"])),  axis=1)
-
-    rots = np.stack((np.asarray(plydata.elements[0]["rot_0"]),
-                     np.asarray(plydata.elements[0]["rot_1"]),
-                     np.asarray(plydata.elements[0]["rot_2"]),
-                     np.asarray(plydata.elements[0]["rot_3"])),  axis=1)
-
-    rots /= np.linalg.norm(rots, axis=1)[:, np.newaxis]
-
-    sh_dim = len(plydata.elements[0][0])-14
-    shs = np.zeros([pws.shape[0], sh_dim])
-    shs[:, 0] = np.asarray(plydata.elements[0]["f_dc_0"])
-    shs[:, 1] = np.asarray(plydata.elements[0]["f_dc_1"])
-    shs[:, 2] = np.asarray(plydata.elements[0]["f_dc_2"])
-
-    sh_rest_dim = sh_dim - 3
-    for i in range(sh_rest_dim):
-        name = "f_rest_%d" % i
-        shs[:, 3 + i] = np.asarray(plydata.elements[0][name])
-
-    shs[:, 3:] = shs[:, 3:].reshape(-1, 3, sh_rest_dim//3).transpose([0, 2, 1]).reshape(-1, sh_rest_dim)
-
-    pws = pws.astype(np.float32)
-    rots = rots.astype(np.float32)
-    scales = np.exp(scales)
-    scales = scales.astype(np.float32)
-    alphas = alphas.astype(np.float32)
-    shs = shs.astype(np.float32)
-
-    dtypes = gsdata_type(sh_dim)
-
-    gs = np.rec.fromarrays(
-        [pws, rots, scales, alphas, shs], dtype=dtypes)
-
-    return gs
-
-
-def rotate_gaussian(T, gs):
-    # Transform to world
-    pws = (T @ gs['pw'].T).T
-    w = gs['rot'][:, 0]
-    x = gs['rot'][:, 1]
-    y = gs['rot'][:, 2]
-    z = gs['rot'][:, 3]
-    R = np.array([
-        [1.0 - 2*(y**2 + z**2), 2*(x*y - z*w), 2*(x * z + y * w)],
-        [2*(x*y + z*w), 1.0 - 2*(x**2 + z**2), 2*(y*z - x*w)],
-        [2*(x*z - y*w), 2*(y*z + x*w), 1.0 - 2*(x**2 + y**2)]
-    ]).transpose(2, 0, 1)
-    R_new = T @ R
-    rots = matrix_to_quaternion(R_new)
-    gs['pw'] = pws
-    gs['rot'] = rots
-    return gs
-
-
-def load_gs(fn):
-    if fn.endswith('.ply'):
-        return load_ply(fn)
-    elif fn.endswith('.npy'):
-        return np.load(fn)
-    else:
-        print("%s is not a supported file." % fn)
-        exit(0)
-
-
-def save_gs(fn, gs):
-    np.save(fn, gs)
-
-
-def get_example_gs():
-    gs_data = np.array([[0.,  0.,  0.,  # xyz
-                         1.,  0.,  0., 0.,  # rot
-                         0.05,  0.05,  0.05,  # size
-                         1.,
-                         1.772484,  -1.772484,  1.772484],
-                        [1.,  0.,  0.,
-                         1.,  0.,  0., 0.,
-                         0.2,  0.05,  0.05,
-                         1.,
-                         1.772484,  -1.772484, -1.772484],
-                        [0.,  1.,  0.,
-                         1.,  0.,  0., 0.,
-                         0.05,  0.2,  0.05,
-                         1.,
-                         -1.772484, 1.772484, -1.772484],
-                        [0.,  0.,  1.,
-                         1.,  0.,  0., 0.,
-                         0.05,  0.05,  0.2,
-                         1.,
-                         -1.772484, -1.772484,  1.772484]
-                        ], dtype=np.float32)
-    dtypes = gsdata_type(3)
-    gs = np.frombuffer(gs_data.tobytes(), dtype=dtypes)
-    return gs
-
-
-if __name__ == "__main__":
-    gs = load_gs("/home/liu/workspace/EasyGaussianSplatting/data/final.npy")
-    print(gs.shape)

q3dviewer/glwidget.py

@@ -9,6 +9,7 @@ from q3dviewer.Qt.QtGui import QKeyEvent
 from q3dviewer.base_glwidget import BaseGLWidget
 from q3dviewer.utils import text_to_rgba
 
+
 class SettingWindow(QWidget):
     def __init__(self):
         super().__init__()
@@ -57,10 +58,11 @@ class GLWidget(BaseGLWidget):
         super(GLWidget, self).__init__()
 
     def keyPressEvent(self, ev: QKeyEvent):
-        if ev.key() == QtCore.Qt.Key_M:  # setting meun
+        if ev.key() == QtCore.Qt.Key_M:  # setting menu
             print("Open setting windows")
-            self.open_setting_window()
-        super().keyPressEvent(ev)
+            self.open_setting_window()            
+        else:
+            super().keyPressEvent(ev)
 
     def on_followable_selection(self, index):
         self.followed_name = self.followable_item_name[index]
@@ -126,3 +128,21 @@ class GLWidget(BaseGLWidget):
 
     def change_show_center(self, state):
         self.enable_show_center = state
+
+    def get_camera_pose(self):
+        """Get current camera pose parameters"""
+        camera_pose = {
+            'center': self.center.tolist() if hasattr(self.center, 'tolist') else list(self.center),
+            'euler': self.euler.tolist() if hasattr(self.euler, 'tolist') else list(self.euler),
+            'distance': float(self.dist),
+        }
+        return camera_pose
+
+    def set_camera_pose(self, config):
+        """Set camera pose from parameters"""
+        if 'center' in config and 'euler' in config and 'distance' in config:
+            self.set_center(config['center'])
+            self.set_euler(config['euler'])
+            self.set_dist(config['distance'])
+        else:
+            print("Invalid camera pose config")

q3dviewer/shaders/cloud_frag.glsl

@@ -1,9 +1,9 @@
+#version 330 core
 /*
 Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
 Distributed under MIT license. See LICENSE for more information.
 */
 
-#version 330 core
 
 uniform int point_type;