q3dviewer 1.1.6__tar.gz → 1.1.9__tar.gz

q3dviewer-1.1.9/PKG-INFO

@@ -0,0 +1,226 @@
+Metadata-Version: 2.1
+Name: q3dviewer
+Version: 1.1.9
+Summary: A library designed for quickly deploying a 3D viewer.
+Home-page: https://github.com/scomup/q3dviewer
+Author: Liu Yang
+License: UNKNOWN
+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 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:
+        
+        ```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.
+        
+        ### Note for Linux Users
+        
+        If you encounter an error related to loading the shared library `libxcb-cursor.so.0` on Ubuntu 20.04 or 22.04, please install `libxcb-cursor0`:
+        
+        ```bash
+        sudo apt-get install libxcb-cursor0
+        ```
+        
+        ## Tools
+        
+        Once installed, you can directly use the following tools:
+        
+        ### 1. Cloud Viewer
+        
+        A tool for visualizing point cloud files (LAS, PCD, PLY, E57). Launch it by executing the following command in your terminal:
+        
+        ```sh
+        cloud_viewer
+        ```
+        
+        *Alternatively*, if the path is not set (though it's not recommended):
+        
+        ```sh
+        python3 -m q3dviewer.tools.cloud_viewer
+        ```
+        
+        **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:
+        
+        [Tokyo Point Clouds](https://www.geospatial.jp/ckan/dataset/tokyopc-23ku-2024/resource/7807d6d1-29f3-4b36-b0c8-f7aa0ea2cff3)
+        
+        ![Cloud Viewer 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 for `CloudItem`.
+        
+        ![Cloud Viewer Settings](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 compatible with ROS, serving as an alternative to RVIZ.
+        
+        ```sh
+        roscore &
+        ros_viewer
+        ```
+        
+        ### 3. Film Maker
+        
+        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
+        ```
+        
+        **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: 
+        
+        ![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
+        
+        A simple viewer for 3D Gaussians. See [EasyGaussianSplatting](https://github.com/scomup/EasyGaussianSplatting) for more information.
+        
+        ```sh
+        gaussian_viewer  # Drag and drop your Gaussian file onto the window
+        ```
+        
+        ![Gaussian Viewer GIF](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/441e6f5a-214d-f7c1-11bf-5fa79e63b38e.gif)
+        
+        ### 5. 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)
+        
+        ### 6. 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**: Displays coordinate axes or the origin position.
+        - **CloudItem**: Displays point clouds.
+        - **CloudIOItem**: Displays point clouds with input/output capabilities.
+        - **GaussianItem**: Displays 3D Gaussians.
+        - **GridItem**: Displays grids.
+        - **ImageItem**: Displays 2D images.
+        - **Text2DItem**: Displays 2D text.
+        - **Text3DItem**: Displays 3D test and mark.
+        - **LineItem**: Displays 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 q3dviewer.Qt.QtWidgets import QLabel, QSpinBox
+        
+        class YourItem(q3d.BaseItem):
+            def __init__(self):
+                super(YourItem, self).__init__()
+                # 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):
+                # Obtain the data you want to visualize
+                pass
+        
+            def initialize_gl(self):
+                # OpenGL initialization settings (if needed)
+                pass
+        
+            def paint(self):
+                # Visualize 3D objects using OpenGL
+                pass
+        ```
+        
+        Enjoy using `q3dviewer`!
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown

{q3dviewer-1.1.6 → q3dviewer-1.1.9}/README.md

@@ -4,7 +4,7 @@
 [![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.
+`q3dviewer` is a library designed for quickly deploying a 3D viewer. It is based on Qt 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).
@@ -173,6 +173,7 @@ if __name__ == '__main__':
 - **GridItem**: Displays grids.
 - **ImageItem**: Displays 2D images.
 - **Text2DItem**: Displays 2D text.
+- **Text3DItem**: Displays 3D test and mark.
 - **LineItem**: Displays lines or trajectories.
 
 ### Developing Custom Items
@@ -183,7 +184,7 @@ In addition to the standard 3D items provided, you can visualize custom 3D items
 from OpenGL.GL import *
 import numpy as np
 import q3dviewer as q3d
-from PySide6.QtWidgets import QLabel, QSpinBox
+from q3dviewer.Qt.QtWidgets import QLabel, QSpinBox
 
 class YourItem(q3d.BaseItem):
     def __init__(self):

{q3dviewer-1.1.6 → q3dviewer-1.1.9}/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-1.1.6 → q3dviewer-1.1.9}/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-1.1.6 → q3dviewer-1.1.9}/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-1.1.6 → q3dviewer-1.1.9}/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-1.1.6 → q3dviewer-1.1.9}/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-1.1.9/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()