q3dviewer 1.1.7__py3-none-any.whl → 1.1.9__py3-none-any.whl

q3dviewer/Qt/__init__.py

@@ -44,6 +44,7 @@ def import_module(name):
 
 
 def load_qt():
+    global Q3D_QT_IMPL, Q3D_DEBUG
     if Q3D_DEBUG is not None:
         print(f'Using {Q3D_QT_IMPL} as Qt binding.')
 

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,82 @@ 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, x0, y0, radius=5):
+        """
+        Get the 3D point in world coordinates corresponding to the given
+        screen coordinates (x0, y0). It searches within a radius around the
+        given pixel to find a valid depth value.
+        """
+        self.makeCurrent()  # Ensure the OpenGL context is current
+        width = self.current_width()
+        height = self.current_height()  
+
+        # Scale mouse coordinates by device pixel ratio for PySide6 compatibility
+        pixel_ratio = self.devicePixelRatioF()
+
+        points = []
+        for dx in range(-radius, radius + 1):
+            for dy in range(-radius, radius + 1):
+                if dx * dx + dy * dy <= radius * radius:
+                    points.append((x0 + dx, y0 + dy))
+        points = sorted(points, key=lambda p: (p[0]-x0)**2 + (p[1]-y0)**2)
+
+        print("points to check:", len(points))
+
+        gl_y0 = height - y0 - 1
+        z = 1.0
+        for x, y in points:
+            x = int(x * pixel_ratio)
+            y = int(y * pixel_ratio)
+
+            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 and z != 0.0:
+                print("dist to  p:", np.sqrt((x - x0)**2 + (y - y0)**2))
+                break
+
+        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 = (x0 / width) * 2.0 - 1.0
+        ndc_y = (gl_y0 / 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', 
@@ -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])
@@ -147,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):
@@ -226,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
@@ -296,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)
@@ -329,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,152 @@
+"""
+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 OpenGL.GL import *
+import numpy as np
+
+try:
+    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_24,
+    )
+    GLUT_AVAILABLE = True
+except ImportError:
+    GLUT_AVAILABLE = False
+    print("Warning: GLUT not available. Text will not be rendered.")
+
+def get_glut_font(font_size):
+    """Get GLUT font based on size, only if GLUT is available"""
+    if not GLUT_AVAILABLE:
+        return None
+    
+    # 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):
+        """Initialize OpenGL resources, with GLUT fallback handling"""
+        global GLUT_AVAILABLE
+        if GLUT_AVAILABLE:
+            try:
+                # Check if glutInit is actually callable before calling it
+                if hasattr(glutInit, '__call__') and bool(glutInit):
+                    glutInit()
+                else:
+                    print("Warning: glutInit not callable, using fallback text rendering")
+                    GLUT_AVAILABLE = False
+            except Exception as e:
+                print(f"Warning: GLUT initialization failed: {e}. Using fallback text rendering.")
+                GLUT_AVAILABLE = False
+        # 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
+
+            # Convert numpy array to tuple if needed
+            if isinstance(pos, np.ndarray):
+                pos = tuple(pos.astype(float))
+            
+            glColor4f(*color)
+            
+            if point_size > 0.0:
+                # draw a point at the position
+                glPointSize(point_size)
+                glBegin(GL_POINTS)
+                glVertex3f(*pos)
+                glEnd()
+            
+            # Text rendering with GLUT fallback
+            if GLUT_AVAILABLE:
+                offset = 0.02
+                pos_text = (pos[0] + offset, pos[1] + offset, pos[2] + offset)
+                glRasterPos3f(*pos_text)
+                font = get_glut_font(font_size)
+                if font is not None:
+                    try:
+                        for ch in text:
+                            glutBitmapCharacter(font, ord(ch))
+                    except Exception as e:
+                        print(f"Error rendering text '{text}': {e}")
+
+        # 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/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;
 

q3dviewer/shaders/cloud_vert.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
 
 layout (location = 0) in vec3 position;
 layout (location = 1) in uint value;
@@ -17,7 +17,7 @@ uniform float vmin = 0;
 uniform float vmax = 255;
 uniform float focal = 1000;
 uniform int point_type = 0; // 0 pixel, 1 flat square, 2 sphere
-uniform float point_size = 0.01;  // World size for each point (meter)
+uniform int point_size = 1;  // World size for each point (pixel or cm)
 out vec4 color;
 
 vec3 getRainbowColor(uint value_raw) {
@@ -47,9 +47,9 @@ void main()
 
     // Calculate point size in pixels based on distance
     if (point_type == 0)
-        gl_PointSize = int(point_size);
+        gl_PointSize = float(point_size);
     else
-        gl_PointSize = point_size / gl_Position.w * focal;
+        gl_PointSize = (float(point_size) * 0.01) / gl_Position.w * focal;
     vec3 c = vec3(1.0, 1.0, 1.0);
     if (color_mode == 1)
     {

q3dviewer/shaders/gau_frag.glsl

@@ -1,9 +1,9 @@
+#version 430 core
 /*
 this file is modified from GaussianSplattingViewer licensed under the MIT License.
 see https://github.com/limacv/GaussianSplattingViewer/blob/main/shaders/gau_frag.glsl
 */
 
-#version 430 core
 
 in vec3 color;
 in float alpha;

q3dviewer/shaders/gau_prep.glsl

@@ -1,10 +1,10 @@
+#version 430 core
 /*
 We proprocess gaussian using compute shader.
 this file is modified from GaussianSplattingViewer licensed under the MIT License.
 see https://github.com/limacv/GaussianSplattingViewer/blob/main/shaders/gau_vert.glsl
 */
 
-#version 430 core
 
 layout(local_size_x = 256, local_size_y = 1, local_size_z = 1) in;
 

q3dviewer/shaders/gau_vert.glsl

@@ -1,3 +1,4 @@
+#version 430 core
 /*
 Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
 Distributed under MIT license. See LICENSE for more information.
@@ -5,7 +6,6 @@ Distributed under MIT license. See LICENSE for more information.
 
 //draw 2d gaussian using proprocess data.
 
-#version 430 core
 
 #define OFFSET_PREP_U 0
 #define OFFSET_PREP_COVINV 3

q3dviewer/shaders/sort_by_key.glsl

@@ -1,3 +1,4 @@
+#version 430 core
 /*
 Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
 Distributed under MIT license. See LICENSE for more information.
@@ -8,7 +9,6 @@ opengl compute shader.
 sort guassian by depth using bitonic sorter
 */
 
-#version 430 core
 
 layout(local_size_x = 256, local_size_y = 1, local_size_z = 1) in;