q3dviewer 1.1.8__py3-none-any.whl → 1.2.0__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

@@ -379,24 +379,48 @@ class BaseGLWidget(QOpenGLWidget):
         return linear_depth
 
 
-    def get_point(self, x, y):
+    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()  
 
-        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]
+        # 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)
+
+        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:
+                break
+
         if z == 1.0 or z == 0.0:
-            return None 
+            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_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)    
 

q3dviewer/custom_items/cloud_item.py

@@ -70,7 +70,6 @@ class CloudItem(BaseItem):
         self.need_update_setting = True
         self.max_cloud_size = 300000000
         # Enable depth test when full opaque
-        self.depth_test = depth_test
         self.path = os.path.dirname(__file__)
 
     def add_setting(self, layout):
@@ -126,13 +125,6 @@ class CloudItem(BaseItem):
         self.slider_v.rangeChanged.connect(self._on_range)
         layout.addWidget(self.slider_v)
 
-        self.checkbox_depth_test = QCheckBox(
-            "Show front points first (Depth Test)")
-        self.checkbox_depth_test.setChecked(self.depth_test)
-        self.checkbox_depth_test.stateChanged.connect(self.set_depthtest)
-        self._on_color_mode(self.color_mode)
-        layout.addWidget(self.checkbox_depth_test)
-
     def _on_range(self, lower, upper):
         self.vmin = lower
         self.vmax = upper
@@ -192,9 +184,6 @@ class CloudItem(BaseItem):
         self.size = size
         self.need_update_setting = True
 
-    def set_depthtest(self, state):
-        self.depth_test = state
-
     def clear(self):
         data = np.empty((0), self.data_type)
         self.set_data(data)
@@ -304,15 +293,16 @@ class CloudItem(BaseItem):
     def paint(self):
         self.update_render_buffer()
         self.update_setting()
+        
         glEnable(GL_BLEND)
         glEnable(GL_PROGRAM_POINT_SIZE)
         glEnable(GL_POINT_SPRITE)
         glEnable(GL_DEPTH_TEST)
         
-        if not self.depth_test:
-            glDepthFunc(GL_ALWAYS)  # Always pass depth test but still write depth
+        if self.alpha < 0.9:
+            glDepthFunc(GL_ALWAYS)
         else:
-            glDepthFunc(GL_LESS)    # Normal depth testing
+            glDepthFunc(GL_LESS)
 
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
         glUseProgram(self.program)

q3dviewer/custom_items/text3d_item.py

@@ -4,19 +4,28 @@ 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,
-)
+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
@@ -63,7 +72,19 @@ class Text3DItem(BaseItem):
 
 
     def initialize_gl(self):
-        glutInit()
+        """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()
 
 
@@ -87,20 +108,31 @@ class Text3DItem(BaseItem):
                 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)
-            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))
+            
+            # 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):

q3dviewer/utils/range_slider.py

@@ -37,19 +37,21 @@ class RangeSlider(QSlider):
             self.active_handle = "upper"
 
     def mouseMoveEvent(self, event):
-        """Override to update handle positions."""
+        """Override to update handle positions, always clamp and int for cross-platform safety."""
         if event.buttons() != Qt.LeftButton:
             return
 
         pos = self.pixelPosToValue(event.pos())
+        minv, maxv = self.minimum(), self.maximum()
         if self.active_handle == "lower":
-            self.lower_value = max(
-                self.minimum(), min(pos, self.upper_value - 1))
+            self.lower_value = max(minv, min(pos, self.upper_value - 1))
+            self.lower_value = int(round(self.lower_value))
             QToolTip.showText(event.globalPos(), f"Lower: {self.lower_value:.1f}")
         elif self.active_handle == "upper":
-            self.upper_value = min(
-                self.maximum(), max(pos, self.lower_value + 1))
+            self.upper_value = min(maxv, max(pos, self.lower_value + 1))
+            self.upper_value = int(round(self.upper_value))
             QToolTip.showText(event.globalPos(), f"Upper: {self.upper_value:.1f}")
+        # Always emit clamped, int values
         self.rangeChanged.emit(self.lower_value, self.upper_value)
         self.update()
 

{q3dviewer-1.1.8.dist-info → q3dviewer-1.2.0.dist-info}/METADATA

@@ -1,24 +1,25 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.1.8
+Version: 1.2.0
 Summary: A library designed for quickly deploying a 3D viewer.
 Home-page: https://github.com/scomup/q3dviewer
 Author: Liu Yang
+License: UNKNOWN
+Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: pyside6
 Requires-Dist: PyOpenGL
-Requires-Dist: meshio
-Requires-Dist: pypcd4
-Requires-Dist: pye57
-Requires-Dist: laspy
 Requires-Dist: imageio
 Requires-Dist: imageio[ffmpeg]
+Requires-Dist: laspy
 Requires-Dist: matplotlib
+Requires-Dist: meshio
+Requires-Dist: numpy
+Requires-Dist: pye57
+Requires-Dist: pypcd4
+Requires-Dist: pyside6
 
 
 ![q3dviewer Logo](imgs/logo.png)
@@ -171,7 +172,7 @@ def main():
 
     # Create a viewer
     viewer = q3d.Viewer(name='example')
-    
+
     # Add items to the viewer
     viewer.add_items({
         'grid': grid_item,
@@ -234,3 +235,4 @@ class YourItem(q3d.BaseItem):
 ```
 
 Enjoy using `q3dviewer`!
+

{q3dviewer-1.1.8.dist-info → q3dviewer-1.2.0.dist-info}/RECORD

@@ -1,22 +1,19 @@
 q3dviewer/__init__.py,sha256=cjyfUE5zK6xohDGDQIWfb0DKkWChVznBd7CrVLg7whQ,376
-q3dviewer/base_glwidget.py,sha256=0AWYwOntyCSterxOebTg_VwStPYV6k1H_BDRGHl41bo,14382
+q3dviewer/base_glwidget.py,sha256=QxAuZzQSBbzTwpHHqYpiM-Jqv41E4YJmFG4KRF-HruY,15274
 q3dviewer/base_item.py,sha256=63MarHyoWszPL40ox-vPoOAQ1N4ypekOjoRARdPik-E,1755
-q3dviewer/gau_io.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 q3dviewer/glwidget.py,sha256=EmrxPtVQ8RdPK5INKMlpKpVfX0KCfjSKRdGf4cSB1f0,5405
 q3dviewer/viewer.py,sha256=Vq3ucDlBcBBoiVVGmqG1sRjhLePl50heblx6wJpsc1A,2603
-q3dviewer/.vscode/c_cpp_properties.json,sha256=rcEXwMKO_Fve86bpEeEhoWRKzdLSVuG5dbNCtE5U3Fw,1037
-q3dviewer/.vscode/settings.json,sha256=3G4gE-fW3vfObgaZrlJzAG7vym2pIfr0fNnL8Jo3RJo,322
-q3dviewer/Qt/__init__.py,sha256=CcwS6oSXBXTMr58JNbRNYcPMVubDD2jiPtJ55DoLm8o,2199
+q3dviewer/Qt/__init__.py,sha256=VJj7Ge6N_81__T9eHFl_YQpa1HyQrlLhMqC_9pUOYtc,2233
 q3dviewer/custom_items/__init__.py,sha256=cwcNn40MzYXVO9eSzpRknJdzZNKPf2kaEMZy5DCNYcE,567
 q3dviewer/custom_items/axis_item.py,sha256=-WM2urosqV847zpTpOtxdLjb7y9NJqFCH13qqodcCTg,2572
 q3dviewer/custom_items/cloud_io_item.py,sha256=Haz-SOUUCPDSHgmKyyyFfP7LXBSEiN4r8xmchQwCm-k,4721
-q3dviewer/custom_items/cloud_item.py,sha256=NkZ5rFM_hVxBPMZYml3oX2CI5d0ApJY1wet8I1eIssE,14024
+q3dviewer/custom_items/cloud_item.py,sha256=McZmTKFllQn0ZiVJDzJJnpcZ-jpgzfO3tLPp03rop7E,13520
 q3dviewer/custom_items/frame_item.py,sha256=bUzww3tSDah0JZeqtU6_cYHhhTVWzXhJVMcAa5pCXHI,7458
 q3dviewer/custom_items/gaussian_item.py,sha256=JMubpahkTPh0E8ShL3FLTahv0e35ODzjgK5K1i0YXSU,9884
 q3dviewer/custom_items/grid_item.py,sha256=LDB_MYACoxld-xvz01_MfAf12vLcRkH7R_WtGHHdSgk,4945
 q3dviewer/custom_items/image_item.py,sha256=k7HNTqdL2ckTbxMx7A7eKaP4aksZ85-pBjNdbpm6PXM,5355
 q3dviewer/custom_items/line_item.py,sha256=rel-lx8AgjDY7qyIecHxHQZzaswRn2ZTiOIjB_0Mrqo,4444
-q3dviewer/custom_items/text3d_item.py,sha256=mQX-8ldUsPcM3ef77fevsXqVJY0_lnNsxCGrtpF4b-A,4167
+q3dviewer/custom_items/text3d_item.py,sha256=DYBPXnCmMEzWDE1y523YsWSl91taXAdu0kdnhUcwE4A,5524
 q3dviewer/custom_items/text_item.py,sha256=toeGjBu7RtT8CMUuaDWnmXPnA1UKHhnCzUNeonGczSo,2703
 q3dviewer/shaders/cloud_frag.glsl,sha256=psKVt9qI6BW0bCqOk4lcKqUd6XgYGtdFigyN9OdYSNI,609
 q3dviewer/shaders/cloud_vert.glsl,sha256=gKI6EJrzX5ga2W2yjU6x7Wjz7Cu2Y-wrPl4g10RfTLM,2376
@@ -24,10 +21,7 @@ q3dviewer/shaders/gau_frag.glsl,sha256=vWt5I3Ojrc2PCxRlBJGyJhujbveSicMA54T01Fk29
 q3dviewer/shaders/gau_prep.glsl,sha256=0BiWhYCQGeX2iN-e7m3dy1xWXqWrErErRAzHlcmWHF0,7218
 q3dviewer/shaders/gau_vert.glsl,sha256=_rkm51zaWgPDJ-otJL-WX12fDvnPBOTooVfqo21Rexs,1666
 q3dviewer/shaders/sort_by_key.glsl,sha256=M5RK6uRDp40vVH6XtBIrdJTcYatqXyZwd6kCzEa2DZg,1097
-q3dviewer/test/test_interpolation.py,sha256=rR_CXsYFLpn0zO0mHf_jL-naluDBMSky--FviOQga0Q,1657
-q3dviewer/test/test_rendering.py,sha256=CrJkJjxkcizZxC4MVyDuJjY_41-eeiD5u0vD_8VFHgU,2206
 q3dviewer/tools/__init__.py,sha256=01wG7BGM6VX0QyFBKsqPmyf2e-vrmV_N3-mo-VQ1VBg,20
-q3dviewer/tools/cinematographer.py,sha256=o_24SSQ4mF062QQ7Gv3i90v7fA79PcHLB03UHXufuEA,13950
 q3dviewer/tools/cloud_viewer.py,sha256=UsKALGiFR2Ck___LSGNPIZ3PPUlECO20jVkcP5g6yyc,6807
 q3dviewer/tools/example_viewer.py,sha256=C867mLnCBjawS6LGgRsJ_c6-6wztfL9vOBQt85KbbdU,572
 q3dviewer/tools/film_maker.py,sha256=xLFgRhFWoMQ37qlvcu1lXWaTWXMNRYlRcZFfHW5JtmQ,16676
@@ -41,10 +35,10 @@ q3dviewer/utils/convert_ros_msg.py,sha256=lNbLIawJfwp3VzygdW3dUXkfSG8atg_CoZbQFm
 q3dviewer/utils/gl_helper.py,sha256=dRY_kUqyPMr7NTcupUr6_VTvgnj53iE2C0Lk0-oFYsI,1435
 q3dviewer/utils/helpers.py,sha256=SqR4YTQZi13FKbkVUYgodXce1JJ_YmrHEIRkUmnIUas,3085
 q3dviewer/utils/maths.py,sha256=zHaPtvVZIuo8xepIXCMeSL9tpx8FahUrq0l4K1oXrBk,8834
-q3dviewer/utils/range_slider.py,sha256=9djTxuzmzH54DgSwAljRpLGjsrIJ0hTxhaxFjPxsk8g,4007
-q3dviewer-1.1.8.dist-info/LICENSE,sha256=81cMOyNfw8KLb1JnPYngGHJ5W83gSbZEBU9MEP3tl-E,1124
-q3dviewer-1.1.8.dist-info/METADATA,sha256=oAsXecjioM4FjtdSDR-8nOjte6sAMxyA0nAklwItxsQ,8014
-q3dviewer-1.1.8.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-q3dviewer-1.1.8.dist-info/entry_points.txt,sha256=aeUdGH7UIgMZEMFUc-0xPZWspY95GoPdZcZuLceq85g,361
-q3dviewer-1.1.8.dist-info/top_level.txt,sha256=HFFDCbGu28txcGe2HPc46A7EPaguBa_b5oH7bufmxHM,10
-q3dviewer-1.1.8.dist-info/RECORD,,
+q3dviewer/utils/range_slider.py,sha256=Cs_xrwt6FCDVxGxan7r-ARd5ySwQ50xnCzcmz0dB_X0,4215
+q3dviewer-1.2.0.dist-info/LICENSE,sha256=81cMOyNfw8KLb1JnPYngGHJ5W83gSbZEBU9MEP3tl-E,1124
+q3dviewer-1.2.0.dist-info/METADATA,sha256=RFXc1PDLrmk1xqidvKx4RoU0_aBfK1aYyQK_TZs3bp0,8024
+q3dviewer-1.2.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+q3dviewer-1.2.0.dist-info/entry_points.txt,sha256=EOjker7XYaBk70ffvNB_knPcfA33Bnlg21ZjEeM1EyI,362
+q3dviewer-1.2.0.dist-info/top_level.txt,sha256=HFFDCbGu28txcGe2HPc46A7EPaguBa_b5oH7bufmxHM,10
+q3dviewer-1.2.0.dist-info/RECORD,,

{q3dviewer-1.1.8.dist-info → q3dviewer-1.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{q3dviewer-1.1.8.dist-info → q3dviewer-1.2.0.dist-info}/entry_points.txt

@@ -6,3 +6,4 @@ lidar_calib = q3dviewer.tools.lidar_calib:main
 lidar_cam_calib = q3dviewer.tools.lidar_cam_calib:main
 mesh_viewer = q3dviewer.tools.mesh_viewer:main
 ros_viewer = q3dviewer.tools.ros_viewer:main
+

q3dviewer/.vscode/c_cpp_properties.json

@@ -1,30 +0,0 @@
-{
-  "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

@@ -1,10 +0,0 @@
-{
-    "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/test/test_interpolation.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
-Distributed under MIT license. See LICENSE for more information.
-"""
-
-"""
-this script tests interpolation of 3D poses.
-"""
-
-
-import numpy as np
-from q3dviewer.utils.maths import expSO3, logSO3, makeT, makeRt
-
-
-def interpolate_pose(T1, T2, v_max, omega_max, dt=0.1):
-    R1, t1 = makeRt(T1)
-    R2, t2 = makeRt(T2)
-    
-    # Get transform time based on linear velocity
-    d = np.linalg.norm(t2 - t1)
-    t_lin = d / v_max
-    
-    # Get transform time based on angular velocity
-    omega = logSO3(R2 @ R1.T)
-    theta = np.linalg.norm(omega)
-    t_ang = theta / omega_max
-    
-    # Get total time based on the linear and angular time
-    t_total = max(t_lin, t_ang)
-    num_steps = int(np.ceil(t_total / dt))
-    
-    # Generate interpolated transforms
-    interpolated_Ts = []
-    for i in range(num_steps + 1):
-        s = i / num_steps
-        t_interp = (1 - s) * t1 + s * t2
-        # Interpolate rotation using SO3
-        R_interp = expSO3(s * omega) @ R1
-        T_interp = makeT(R_interp, t_interp)
-        interpolated_Ts.append(T_interp)
-    
-    return interpolated_Ts
-
-if __name__ == "__main__":
-    T1 = np.eye(4)  # Identity transformation
-    T2 = np.array([[0, -1, 0, 1], [1, 0, 0, 2], [0, 0, 1, 3], [0, 0, 0, 1]])  # Target transformation
-
-    v_max = 1.0  # Maximum linear velocity (m/s)
-    omega_max = np.pi / 4  # Maximum angular velocity (rad/s)
-
-    # Perform interpolation
-    interpolated_poses = interpolate_pose(T1, T2, v_max, omega_max)
-    for i, T in enumerate(interpolated_poses):
-        print(f"Step {i}:\n{T}\n")
-
-

q3dviewer/test/test_rendering.py

@@ -1,73 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
-Distributed under MIT license. See LICENSE for more information.
-"""
-
-"""
-this script tests the rendering of a cloud in a camera frame based on the 
-camera pose and intrinsic matrix
-"""
-
-import numpy as np
-import q3dviewer as q3d
-import cv2
-from q3dviewer.utils.cloud_io import load_pcd
-
-cloud, _ = load_pcd('/home/liu/lab.pcd')
-
-
-Tcw = np.array([[7.07106781e-01,  7.07106781e-01,  0.00000000e+00,
-                 0.00000000e+00],
-                [-3.53553391e-01,  3.53553391e-01,  8.66025404e-01,
-                 3.55271368e-15],
-                [6.12372436e-01, -6.12372436e-01,  5.00000000e-01,
-                 -4.00000000e+01],
-                [0.00000000e+00,  0.00000000e+00,  0.00000000e+00,
-                 1.00000000e+00]])
-# convert the opengl camera coordinate to the opencv camera coordinate
-Tconv = np.array([[1, 0, 0, 0],
-                  [0, -1, 0, 0],
-                  [0, 0, -1, 0],
-                  [0, 0, 0, 1]])
-
-Tcw = Tconv @ Tcw
-
-K = np.array([[1.64718029e+03, 0.00000000e+00, 9.51000000e+02],
-              [0.00000000e+00, 1.64718036e+03, 5.31000000e+02],
-              [0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])
-
-
-def render_frame(cloud, Tcw, K, width, height):
-    image = np.zeros((height, width, 3), dtype=np.uint8)
-    Rcw, tcw = Tcw[:3, :3], Tcw[:3, 3]
-    pc = (Rcw @ cloud['xyz'].T).T + tcw
-    uv = (K @ pc.T).T
-    uv = uv[:, :2] / uv[:, 2][:, np.newaxis]
-    mask = (pc[:, 2] > 0) & (uv[:, 0] > 0) & (
-        uv[:, 0] < width) & (uv[:, 1] > 0) & (uv[:, 1] < height)
-    uv = uv[mask]
-    u = uv[:, 0].astype(int)
-    v = uv[:, 1].astype(int)
-    rgb = cloud['irgb'][mask]
-    r = rgb >> 16 & 0xff
-    g = rgb >> 8 & 0xff
-    b = rgb & 0xff
-
-    # Sort by depth to ensure front points are drawn first
-    depth = pc[mask, 2]
-    sorted_indices = np.argsort(depth)
-    u = u[sorted_indices]
-    v = v[sorted_indices]
-    r = r[sorted_indices]
-    g = g[sorted_indices]
-    b = b[sorted_indices]
-
-    image[v, u] = np.stack([b, g, r], axis=1)
-    return image
-
-
-image = render_frame(cloud, Tcw, K, 1902, 1062)
-cv2.imshow('image', image)
-cv2.waitKey(0)

q3dviewer/tools/cinematographer.py

@@ -1,367 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
-Distributed under MIT license. See LICENSE for more information.
-"""
-
-import numpy as np
-import q3dviewer as q3d
-from PySide6.QtWidgets import QVBoxLayout, QListWidget, QListWidgetItem, QPushButton, QDoubleSpinBox, QCheckBox, QLineEdit, QMessageBox, QLabel, QHBoxLayout
-from PySide6.QtCore import QTimer
-from cloud_viewer import ProgressDialog,  FileLoaderThread
-from PySide6 import QtCore
-from PySide6.QtGui import QKeyEvent
-from q3dviewer import GLWidget
-import imageio.v2 as imageio
-import os
-
-
-class KeyFrame:
-    def __init__(self, Twc):
-        self.Twc = Twc
-        self.linear_velocity = 10
-        self.angular_velocity = 1
-        self.stop_time = 0
-        self.item = q3d.FrameItem(Twc, width=3, color='#0000FF')
-
-
-class CustomGLWidget(GLWidget):
-    def __init__(self, viewer):
-        super().__init__()
-        self.viewer = viewer  # Add a viewer handle
-
-    def keyPressEvent(self, ev: QKeyEvent):
-        if ev.key() == QtCore.Qt.Key_Space:
-            self.viewer.add_key_frame()
-        elif ev.key() == QtCore.Qt.Key_Delete:
-            self.viewer.del_key_frame()
-        super().keyPressEvent(ev)
-
-class CMMViewer(q3d.Viewer):
-    """
-    This class is a subclass of Viewer, which is used to create a cloud movie maker.
-    """
-    def __init__(self, **kwargs):
-        self.key_frames = []
-        self.video_path = os.path.join(os.path.expanduser("~"), "output.mp4")
-        super().__init__(**kwargs, gl_widget_class=lambda: CustomGLWidget(self))
-        # for drop cloud file
-        self.setAcceptDrops(True)
-
-    def add_control_panel(self, main_layout):
-        """
-        Add a control panel to the viewer.
-        """
-        # Create a vertical layout for the settings
-        setting_layout = QVBoxLayout()
-
-        # Buttons to add and delete key frames
-        add_button = QPushButton("Add Key Frame")
-        add_button.clicked.connect(self.add_key_frame)
-        setting_layout.addWidget(add_button)
-        del_button = QPushButton("Delete Key Frame")
-        del_button.clicked.connect(self.del_key_frame)
-        setting_layout.addWidget(del_button)
-
-        # Add play/stop button
-        self.play_button = QPushButton("Play")
-        self.play_button.clicked.connect(self.toggle_playback)
-        setting_layout.addWidget(self.play_button)
-
-        # add a timer to play the frames
-        self.timer = QTimer()
-        self.timer.timeout.connect(self.play_frames)
-        self.current_frame_index = 0
-        self.is_playing = False
-        self.is_recording = False
-
-        # Add record checkbox
-        self.record_checkbox = QCheckBox("Record")
-        self.record_checkbox.stateChanged.connect(self.toggle_recording)
-        setting_layout.addWidget(self.record_checkbox)
-
-        # Add video path setting
-        video_path_layout = QHBoxLayout()
-        label_video_path = QLabel("Video Path:")
-        video_path_layout.addWidget(label_video_path)
-        self.video_path_edit = QLineEdit()
-        self.video_path_edit.setText(self.video_path)
-        self.video_path_edit.textChanged.connect(self.update_video_path)
-        video_path_layout.addWidget(self.video_path_edit)
-        setting_layout.addLayout(video_path_layout)
-
-        # Add a list of key frames
-        self.frame_list = QListWidget()
-        setting_layout.addWidget(self.frame_list)
-        self.frame_list.itemSelectionChanged.connect(self.on_select_frame)
-        self.installEventFilter(self)
-
-        # Add spin boxes for linear / angular velocity and stop time
-        self.lin_vel_spinbox = QDoubleSpinBox()
-        self.lin_vel_spinbox.setPrefix("Linear Velocity (m/s): ")
-        self.lin_vel_spinbox.setRange(0, 100)
-        self.lin_vel_spinbox.valueChanged.connect(self.set_frame_lin_vel)
-        setting_layout.addWidget(self.lin_vel_spinbox)
-
-        self.lin_ang_spinbox = QDoubleSpinBox()
-        self.lin_ang_spinbox.setPrefix("Angular Velocity (rad/s): ")
-        self.lin_ang_spinbox.setRange(0, 100)
-        self.lin_ang_spinbox.valueChanged.connect(self.set_frame_ang_vel)
-        setting_layout.addWidget(self.lin_ang_spinbox)
-
-        self.stop_time_spinbox = QDoubleSpinBox()
-        self.stop_time_spinbox.setPrefix("Stop Time: ")
-        self.stop_time_spinbox.setRange(0, 100)
-        self.stop_time_spinbox.valueChanged.connect(self.set_frame_stop_time)
-        setting_layout.addWidget(self.stop_time_spinbox)
-        
-        setting_layout.setAlignment(QtCore.Qt.AlignTop)
-        main_layout.addLayout(setting_layout)
-
-
-    def update_video_path(self, path):
-        self.video_path = path
-
-    def add_key_frame(self):
-        view_matrix = self.glwidget.view_matrix
-        # Get camera pose in world frame
-        Twc = np.linalg.inv(view_matrix)
-        # Add the key frame to the list
-        key_frame = KeyFrame(Twc)
-        current_index = self.frame_list.currentRow()
-        self.key_frames.insert(current_index + 1, key_frame)
-        # visualize this key frame using FrameItem
-        self.glwidget.add_item(key_frame.item)
-        # move the camera back to 0.5 meter, let the user see the frame
-        self.glwidget.update_dist(0.5)
-        # Add the key frame to the Qt ListWidget
-        item = QListWidgetItem(f"Frame {current_index + 2}")
-        self.frame_list.insertItem(current_index + 1, item)
-        self.frame_list.setCurrentRow(current_index + 1)
-        # Update frame labels
-        for i in range(len(self.key_frames)):
-            self.frame_list.item(i).setText(f"Frame {i + 1}")
-
-    def del_key_frame(self):
-        current_index = self.frame_list.currentRow()
-        if current_index >= 0:
-            self.glwidget.remove_item(self.key_frames[current_index].item)
-            self.key_frames.pop(current_index)
-            self.frame_list.itemSelectionChanged.disconnect(self.on_select_frame)
-            self.frame_list.takeItem(current_index)
-            self.frame_list.itemSelectionChanged.connect(self.on_select_frame)
-            self.on_select_frame()
-        # Update frame labels
-        for i in range(len(self.key_frames)):
-            
-            self.frame_list.item(i).setText(f"Frame {i + 1}")
-    
-    def on_select_frame(self):
-        current = self.frame_list.currentRow()
-        for i, frame in enumerate(self.key_frames):
-            if i == current:
-                # Highlight the selected frame
-                frame.item.set_color('#FF0000')
-                frame.item.set_line_width(5)
-                # show current frame's parameters in the spinboxes
-                self.lin_vel_spinbox.setValue(frame.linear_velocity)
-                self.lin_ang_spinbox.setValue(frame.angular_velocity)
-                self.stop_time_spinbox.setValue(frame.stop_time)
-            else:
-                frame.item.set_color('#0000FF')
-                frame.item.set_line_width(3)
-
-    def set_frame_lin_vel(self, value):
-        current_index = self.frame_list.currentRow()
-        if current_index >= 0:
-            self.key_frames[current_index].linear_velocity = value
-
-    def set_frame_ang_vel(self, value):
-        current_index = self.frame_list.currentRow()
-        if current_index >= 0:
-            self.key_frames[current_index].angular_velocity = value
-
-    def set_frame_stop_time(self, value):
-        current_index = self.frame_list.currentRow()
-        if current_index >= 0:
-            self.key_frames[current_index].stop_time = value
-
-    def create_frames(self):
-        """
-        Create the frames for playback by interpolating between key frames.
-        """
-        self.frames = []
-        dt = 1 / float(self.update_interval)
-        for i in range(len(self.key_frames) - 1):
-            current_frame = self.key_frames[i]
-            if current_frame.stop_time > 0:
-                num_steps = int(current_frame.stop_time / dt)
-                for j in range(num_steps):
-                    self.frames.append(current_frame.Twc)
-            next_frame = self.key_frames[i + 1]
-            Ts = q3d.interpolate_pose(current_frame.Twc, next_frame.Twc,
-                                      current_frame.linear_velocity,
-                                      current_frame.angular_velocity,
-                                      dt)
-            self.frames.extend(Ts)
-        
-        print(f"Total frames: {len(self.frames)}")
-        print(f"Total time: {len(self.frames) * dt:.2f} seconds")
-
-    def toggle_playback(self):
-        if self.is_playing:
-            self.stop_playback()
-        else:
-            self.start_playback()
-
-    def start_playback(self):
-        if self.key_frames:
-            self.create_frames()
-            self.current_frame_index = 0
-            self.timer.start(self.update_interval)  # Adjust the interval as needed
-            self.is_playing = True
-            self.play_button.setStyleSheet("")
-            self.play_button.setText("Stop")
-            self.record_checkbox.setEnabled(False)
-            if self.is_recording is True:
-                self.start_recording()
-
-    def stop_playback(self):
-        self.timer.stop()
-        self.is_playing = False
-        self.play_button.setStyleSheet("")
-        self.play_button.setText("Play")
-        self.record_checkbox.setEnabled(True)
-        if self.is_recording:
-            self.stop_recording()
-
-    def play_frames(self):
-        """
-        callback function for the timer to play the frames
-        """
-        # play the frames
-        if self.current_frame_index < len(self.frames):
-            self.glwidget.set_view_matrix(np.linalg.inv(self.frames[self.current_frame_index]))
-            self.current_frame_index += 1
-            if self.is_recording:
-                self.record_frame()
-        else:
-            self.stop_playback()
-
-    def toggle_recording(self, state):
-        if state == 2:
-            self.is_recording = True
-        else:
-            self.is_recording = False
-
-    def start_recording(self):
-        self.is_recording = True
-        self.frames_to_record = []
-        video_path = self.video_path_edit.text()
-        self.play_button.setStyleSheet("background-color: red")
-        self.play_button.setText("Recording")
-        self.writer = imageio.get_writer(video_path, fps=self.update_interval,
-                                         codec="libx264", bitrate="5M", quality=10)
-        # disable the all the frame_item while recording
-        for frame in self.key_frames:
-            frame.item.hide()
-
-    def stop_recording(self, save_movie=True):
-        self.is_recording = False
-        self.record_checkbox.setChecked(False)
-        # enable the all the frame_item after recording
-        for frame in self.key_frames:
-            frame.item.show()
-        if hasattr(self, 'writer') and save_movie:
-            self.writer.close()
-            self.show_save_message()
-
-    def show_save_message(self):
-        msg_box = QMessageBox()
-        msg_box.setIcon(QMessageBox.Information)
-        msg_box.setWindowTitle("Video Saved")
-        msg_box.setText(f"Video saved to {self.video_path_edit.text()}")
-        msg_box.setStandardButtons(QMessageBox.Ok)
-        msg_box.exec()
-
-    def record_frame(self):
-        frame = self.glwidget.capture_frame()
-        # make sure the frame size is multiple of 16
-        height, width, _ = frame.shape
-        if height % 16 != 0 or width % 16 != 0:
-            frame = frame[:-(height % 16), :-(width % 16), :]
-            frame = np.ascontiguousarray(frame)
-        self.frames_to_record.append(frame)
-        try:
-            self.writer.append_data(frame)
-        except Exception as e:
-            print("Don't change the window size during recording.")
-            self.stop_recording(False) # Stop recording without saving
-            self.stop_playback()
-
-    def eventFilter(self, obj, event):
-        if event.type() == QtCore.QEvent.KeyPress:
-            if event.key() == QtCore.Qt.Key_Delete:
-                self.del_key_frame()
-                return True
-        return super().eventFilter(obj, event)
-
-    def dragEnterEvent(self, event):
-        if event.mimeData().hasUrls():
-            event.accept()
-        else:
-            event.ignore()
-
-    def dropEvent(self, event):
-        """
-        Overwrite the drop event to open the cloud file.
-        """
-        self.progress_dialog = ProgressDialog(self)
-        self.progress_dialog.show()
-        files = event.mimeData().urls()
-        self.progress_thread = FileLoaderThread(self, files)
-        self['cloud'].load(files[0].toLocalFile(), append=False)
-        self.progress_thread.progress.connect(self.file_loading_progress)
-        self.progress_thread.finished.connect(self.file_loading_finished)
-        self.progress_thread.start()
-
-    def file_loading_progress(self, value):
-        self.progress_dialog.set_value(value)
-
-    def file_loading_finished(self):
-        self.progress_dialog.close()
-
-    def open_cloud_file(self, file, append=False):
-        cloud_item = self['cloud']
-        if cloud_item is None:
-            print("Can't find clouditem.")
-            return
-        cloud = cloud_item.load(file, append=append)
-        center = np.nanmean(cloud['xyz'].astype(np.float64), axis=0)
-        self.glwidget.set_cam_position(pos=center)
-
-def main():
-    import argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--path", help="the cloud file path")
-    args = parser.parse_args()
-    app = q3d.QApplication(['Cloud Movie Maker'])
-    viewer = CMMViewer(name='Cloud Movie Maker', update_interval=30)
-    cloud_item = q3d.CloudIOItem(size=1, alpha=0.1)
-    axis_item = q3d.AxisItem(size=0.5, width=5)
-    grid_item = q3d.GridItem(size=1000, spacing=20)
-
-    viewer.add_items(
-        {'cloud': cloud_item, 'grid': grid_item, 'axis': axis_item})
-
-    if args.path:
-        pcd_fn = args.path
-        viewer.open_cloud_file(pcd_fn)
-
-    viewer.show()
-    app.exec()
-
-
-if __name__ == '__main__':
-    main()