q3dviewer 1.0.8__py3-none-any.whl → 1.1.0__py3-none-any.whl

q3dviewer/utils/maths.py

@@ -3,9 +3,145 @@ Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
 Distributed under MIT license. See LICENSE for more information.
 """
 
+"""
+Math proofs and implementations: 
+https://github.com/scomup/MathematicalRobotics.git
+"""
+
+
 import numpy as np
 
 
+_epsilon_ = 1e-5
+
+
+def skew(vector):
+    return np.array([[0, -vector[2], vector[1]],
+                     [vector[2], 0, -vector[0]],
+                     [-vector[1], vector[0], 0]])
+
+
+def expSO3(omega):
+    """
+    Exponential map of SO3
+    The proof is shown in 3d_rotation_group.md (10)
+    """
+    theta2 = omega.dot(omega)
+    theta = np.sqrt(theta2)
+    nearZero = theta2 <= _epsilon_
+    W = skew(omega)
+    if (nearZero):
+        return np.eye(3) + W
+    else:
+        K = W/theta
+        KK = K.dot(K)
+        sin_theta = np.sin(theta)
+        one_minus_cos = 1 - np.cos(theta)
+        R = np.eye(3) + sin_theta * K + one_minus_cos * KK  # rotation.md (10)
+        return R
+
+
+def logSO3(R):
+    """
+    Logarithm map of SO3
+    The proof is shown in rotation.md (14)
+    """
+    R11, R12, R13 = R[0, :]
+    R21, R22, R23 = R[1, :]
+    R31, R32, R33 = R[2, :]
+    tr = np.trace(R)
+    omega = np.zeros(3)
+    v = np.array([R32 - R23, R13 - R31, R21 - R12])
+    # when trace == -1, i.e., the theta is approx to +-pi, +-3pi, +-5pi, etc.
+    # we do something special
+    if (tr + 1.0 < 1e-3):
+        if (R33 > R22 and R33 > R11):
+            # R33 is largest
+            # sin(theta) approx to sgn_w*pi-theta, cos(theta) approx to -1
+            W = R21 - R12  # 2*r3*sin(theta) = 2*r3*(sgn_w*pi-theta)
+            Q1 = R31 + R13          # 4 * r1*r3
+            Q2 = R23 + R32          # 4 * r2*r3
+            Q3 = 2.0 + 2.0 * R33    # 4 * r3*r3
+            r = np.sqrt(Q3)         # 2 * r3
+            one_over_r = 1 / r      # 1 / (2*r3)
+            norm = np.sqrt(Q1*Q1 + Q2*Q2 + Q3*Q3 + W*W)  # 4*r3
+            sgn_w = np.sign(W)      # get the sgn of theta
+            mag = np.pi - (2 * sgn_w * W) / norm   # theta*sgn_w
+            scale = 0.5 * mag * one_over_r  # theta * sgn_w / (4*r3)
+            # omega = theta * [4*r1*r3, 4*r2*r3, 4*r3*r3]/ (4*r3)
+            omega = sgn_w * scale * np.array([Q1, Q2, Q3])
+        elif (R22 > R11):
+            # R22 is the largest
+            W = R13 - R31  # 2*r2*sin(theta) = 2*r2*(sgn_w*pi-theta)
+            Q1 = R12 + R21        # 4 * r2*r1
+            Q2 = 2.0 + 2.0 * R22  # 4 * r2*r2
+            Q3 = R23 + R32        # 4 * r2*r3
+            r = np.sqrt(Q2)
+            one_over_r = 1 / r
+            norm = np.sqrt(Q1*Q1 + Q2*Q2 + Q3*Q3 + W*W)
+            sgn_w = np.sign(W)
+            mag = np.pi - (2 * sgn_w * W) / norm
+            scale = 0.5 * one_over_r * mag
+            omega = sgn_w * scale * np.array([Q1, Q2, Q3])
+        else:
+            # R11 is the largest
+            W = R32 - R23  # 2*r1*sin(theta) = 2*r1*(sgn_w*pi-theta)
+            Q1 = 2.0 + 2.0 * R11 # 4 * r1*r1
+            Q2 = R12 + R21       # 4 * r1*r2
+            Q3 = R31 + R13       # 4 * r1*r3
+            r = np.sqrt(Q1)
+            one_over_r = 1 / r
+            norm = np.sqrt(Q1*Q1 + Q2*Q2 + Q3*Q3 + W*W)
+            sgn_w = np.sign(W)
+            mag = np.pi - (2 * sgn_w * W) / norm
+            scale = 0.5 * one_over_r * mag
+            omega = sgn_w * scale * np.array([Q1, Q2, Q3])
+    else:
+        magnitude = 0
+        tr_3 = tr - 3.0
+        if (tr_3 < -1e-6):
+            # this is the normal case -1 < trace < 3
+            theta = np.arccos((tr - 1.0) / 2.0)
+            magnitude = theta / (2.0 * np.sin(theta))
+        else:
+            # when theta near 0, +-2pi, +-4pi, etc. (trace near 3.0)
+            # use Taylor expansion: theta \approx 1/2-(t-3)/12 + O((t-3)^2)
+            # see https://github.com/borglab/gtsam/issues/746 for details
+            magnitude = 0.5 - tr_3 / 12.0 + tr_3*tr_3/60.0
+        omega = magnitude * np.array([R32 - R23, R13 - R31, R21 - R12])
+    return omega
+
+
+def interpolate_pose(T1, T2, v_max, omega_max, dt=0.02):
+    R1, t1 = makeRt(T1)
+    R2, t2 = makeRt(T2)
+    
+    # Get transfrom 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):
+        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
+
+
 def frustum(left, right, bottom, top, near, far):
     # see https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml
     if near <= 0 or far <= 0 or near >= far or left == right or bottom == top:
@@ -157,11 +293,25 @@ def makeRt(T):
     return R, t
 
 def hex_to_rgba(hex_color):
-    color_flat = int(hex_color[1:], 16)
-    red = (color_flat >> 16) & 0xFF
-    green = (color_flat >> 8) & 0xFF
-    blue = color_flat & 0xFF
-    return (red / 255.0, green / 255.0, blue / 255.0, 1.0)
+    if not hex_color.startswith("#"):
+        print("Invalid hex color string.")
+        return (1.0, 1.0, 1.0, 1.0)
+    if len(hex_color) == 7:
+        color_flat = int(hex_color[1:], 16)
+        red = (color_flat >> 16) & 0xFF
+        green = (color_flat >> 8) & 0xFF
+        blue = color_flat & 0xFF
+        return (red / 255.0, green / 255.0, blue / 255.0, 1.0)
+    elif len(hex_color) == 9:
+        color_flat = int(hex_color[1:], 16)
+        red = (color_flat >> 24) & 0xFF
+        green = (color_flat >> 16) & 0xFF
+        blue = (color_flat >> 8) & 0xFF
+        alpha = color_flat & 0xFF
+        return (red / 255.0, green / 255.0, blue / 255.0, alpha / 255.0)
+    else:
+        print("Invalid hex color string.")
+        return (1.0, 1.0, 1.0, 1.0)
 
 # euler = np.array([1, 0.1, 0.1])
 # euler_angles = matrix_to_euler(euler_to_matrix(euler))

q3dviewer/viewer.py

@@ -6,7 +6,7 @@ Distributed under MIT license. See LICENSE for more information.
 
 from q3dviewer.glwidget import *
 import signal
-from PySide6.QtWidgets import QMainWindow, QApplication
+from PySide6.QtWidgets import QMainWindow, QApplication, QHBoxLayout
 
 
 def handler(signal, frame):
@@ -15,22 +15,45 @@ def handler(signal, frame):
 
 
 class Viewer(QMainWindow):
-    def __init__(self, name='Viewer', win_size=[1920, 1080]):
+    def __init__(self, name='Viewer', win_size=[1920, 1080], 
+                 gl_widget_class=GLWidget, update_interval=20):
         signal.signal(signal.SIGINT, handler)
         super(Viewer, self).__init__()
         self.setGeometry(0, 0, win_size[0], win_size[1])
+        self.gl_widget_class = gl_widget_class
         self.init_ui()
+        self.update_interval = update_interval
+        self.add_update_timer()
         self.setWindowTitle(name)
+        self.installEventFilter(self)
 
     def init_ui(self):
         center_widget = QWidget()
         self.setCentralWidget(center_widget)
-        self.layout = QHBoxLayout()
-        center_widget.setLayout(self.layout)
-        self.glwidget = GLWidget()
-        self.layout.addWidget(self.glwidget, 1)
+        main_layout = QHBoxLayout()
+        self.add_control_panel(main_layout)
+        center_widget.setLayout(main_layout)
+        self.glwidget = self.gl_widget_class()
+        main_layout.addWidget(self.glwidget, 1)
+        self.default_gl_setting(self.glwidget)
+
+    def add_control_panel(self, main_layout):
+        """
+        Override this function to add your own control panel to 
+        the left side of the main window.
+        Don't forget add your own layout to the main_layout.
+        """
+        pass
+
+    def default_gl_setting(self, glwidget):
+        """
+        Override this function to set the default opengl setting of the viewer.
+        """
+        pass
+
+    def add_update_timer(self):
         timer = QtCore.QTimer(self)
-        timer.setInterval(20)  # period, in milliseconds
+        timer.setInterval(self.update_interval)  # period, in milliseconds
         timer.timeout.connect(self.update)
         timer.start()
 

q3dviewer-1.1.0.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.1
+Name: q3dviewer
+Version: 1.1.0
+Summary: A library designed for quickly deploying a 3D viewer.
+Home-page: https://github.com/scomup/q3dviewer
+Author: Liu Yang
+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: pillow
+Requires-Dist: meshio
+Requires-Dist: pypcd4
+Requires-Dist: pye57
+Requires-Dist: laspy
+Requires-Dist: imageio
+
+## 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.
+
+## 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. Launch it by executing the following command in your terminal:
+
+```sh
+cloud_viewer  # The viewer will be displayed
+```
+
+*Alternatively*, if the path is not set (though it's not recommended):
+
+```sh
+python3 -m q3dviewer.tools.cloud_viewer
+```
+
+After the viewer launches, you can drag and drop files onto the window to display the point clouds. Multiple files can be dropped simultaneously to view them together. Supported formats include LAS, PCD, PLY, and E57.
+
+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 # drag and drop your cloud file to the window
+```
+
+* Space key to add a keyframe.
+* Delete key to remove a keyframe.
+
+Film Maker GUI: 
+
+![Screenshot from 2025-02-02 18-20-51.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/a1a6ad63-237c-482e-439d-e760223c59ca.png)
+
+### 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.
+- **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 PySide6.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`!

q3dviewer-1.1.0.dist-info/RECORD

@@ -0,0 +1,45 @@
+q3dviewer/__init__.py,sha256=rP5XX_x8g7hxIMqNHlU89BN4dt5MSvoYYwip68fCmhc,173
+q3dviewer/base_glwidget.py,sha256=k4fVwV2A_0CS7zZgHargbKE7push-l2UN7rmr2Z9vFo,10916
+q3dviewer/base_item.py,sha256=lzb04oRaS4rRJrAP6C1Bu4ugK237FgupMTB97zjNVFw,1768
+q3dviewer/gau_io.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+q3dviewer/glwidget.py,sha256=im8hjVYEL0Zl7fOIHTQMJdWu7WNOHlvTdIDYjebz9WA,4940
+q3dviewer/viewer.py,sha256=LH1INLFhi6pRjzazzQJ0AWT4hgyXI6GnmqoJFUwUZVE,2517
+q3dviewer/custom_items/__init__.py,sha256=gOiAxdjDaAnFL8YbqSEWWWOwUrJfvzP9JLR34sCB9-4,434
+q3dviewer/custom_items/axis_item.py,sha256=PTBSf5DmQI8ieSinYjY_aC7P8q1nzE-2Vc2GNd1O3Os,2568
+q3dviewer/custom_items/cloud_io_item.py,sha256=gjK3n9WKB7JwxC93ijkweEHA5EezpgNJ8KO-PBaDKCs,2835
+q3dviewer/custom_items/cloud_item.py,sha256=7r6s_j1qEUfLe70t-M68-oIrGRrPOUcZp18ML6jST0s,12542
+q3dviewer/custom_items/frame_item.py,sha256=6BOM3MXi-Akv6KUXDC3QYEAXKxwk0Eo1KQn-F7jkqrQ,7559
+q3dviewer/custom_items/gaussian_item.py,sha256=CZoXMmj2JPFfMqu7v4q4dLUI2cg_WfE1DHWGXjEYn6M,9869
+q3dviewer/custom_items/grid_item.py,sha256=20n4TGm5YEaudhnEOCOk-HtsKwxVxaPr8YV36kO04yU,4802
+q3dviewer/custom_items/image_item.py,sha256=ctNR81fVgxkdl2n3U_TPFL6yn086UhNI_A9fFHgkc-4,5491
+q3dviewer/custom_items/line_item.py,sha256=u0oFN2iHzsRHtnbvyvC_iglEkCwEU2NnTuE536sKUAE,4348
+q3dviewer/custom_items/text_item.py,sha256=nuHMVMQrwy50lNk9hxB94criFxbJJK-SYiK2fSXWUMQ,2158
+q3dviewer/shaders/cloud_frag.glsl,sha256=tbCsDUp9YlPe0hRWlFS724SH6TtMeLO-GVYROzEElZg,609
+q3dviewer/shaders/cloud_vert.glsl,sha256=Vxgw-Zrr0knAK0z4qMXKML6IC4EbffKMwYN2TMXROoI,2117
+q3dviewer/shaders/gau_frag.glsl,sha256=5_UY84tWDts59bxP8x4I-wgnzY8aGeGuo28wX--LW7E,975
+q3dviewer/shaders/gau_prep.glsl,sha256=eCT9nm65uz32w8NaDjeGKhyAZh42Aea-QTwr3yQVr9U,7218
+q3dviewer/shaders/gau_vert.glsl,sha256=NNbVhv_JyqZDK9iXAyBAcIHAtim7G9yWbC9IaUfTL1w,1666
+q3dviewer/shaders/sort_by_key.glsl,sha256=CA2zOcbyDGYAJSJEUvgjUqNshg9NAehf8ipL3Jsv4qE,1097
+q3dviewer/test/test_interpolation.py,sha256=rR_CXsYFLpn0zO0mHf_jL-naluDBMSky--FviOQga0Q,1657
+q3dviewer/test/test_rendering.py,sha256=gbTcu7-cg20DgC5Zoi17C1s5lBGLfAE1rW9biqPjRsA,2164
+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=10f2LSWpmsXzxrGobXw188doVjJbgBfPoqZPUi35EtI,3867
+q3dviewer/tools/example_viewer.py,sha256=yeVXT0k4-h1vTLKnGzWADZD3our6XUaYUTy0p5daTkE,959
+q3dviewer/tools/film_maker.py,sha256=CC4RuK0bE_-0kcdU6xyzqR47pB4TEcm0g4LlDrFs3qY,16004
+q3dviewer/tools/gaussian_viewer.py,sha256=vIwWmiFhjNmknrEkBLzt2yiegeH7LP3OeNjnGM6GzaI,1633
+q3dviewer/tools/lidar_calib.py,sha256=M01bGg2mT8LwVcYybolr4UW_UUaR-f-BFciEHtjeK-w,10488
+q3dviewer/tools/lidar_cam_calib.py,sha256=SYNLDvi15MX7Q3aGn771fvu1cES9xeXgP0_WmDq33w4,11200
+q3dviewer/tools/ros_viewer.py,sha256=ARB3I5wohY3maP8dCu0O0hxObd6JFKuK2y7AApVgMWA,2551
+q3dviewer/utils/__init__.py,sha256=irm8Z_bT8l9kzhoMlds2Dal8g4iw4vjmqNPZSs4W6e0,157
+q3dviewer/utils/cloud_io.py,sha256=ttD8FJExdDhXB1Z0Ej9S939i8gcq4JfyqwLXVh8CEFw,11094
+q3dviewer/utils/convert_ros_msg.py,sha256=sAoQfy3qLQKsIArBAVm8H--wlQXOcmkKK3-Ox9UCcrc,1686
+q3dviewer/utils/gl_helper.py,sha256=dRY_kUqyPMr7NTcupUr6_VTvgnj53iE2C0Lk0-oFYsI,1435
+q3dviewer/utils/maths.py,sha256=5TmjWUX1K3UjygXxrUsydjbo7tPzu0gD-yy7qtQUGBU,10588
+q3dviewer/utils/range_slider.py,sha256=jZJQL-uQgnpgLvtYSWpKTrJlLkt3aqNpaRQAePEpNd0,3174
+q3dviewer-1.1.0.dist-info/LICENSE,sha256=81cMOyNfw8KLb1JnPYngGHJ5W83gSbZEBU9MEP3tl-E,1124
+q3dviewer-1.1.0.dist-info/METADATA,sha256=hiWxWsKDWmCaXB-lJYhi-kutcydCeafxfzDSgeQv5Y8,6991
+q3dviewer-1.1.0.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+q3dviewer-1.1.0.dist-info/entry_points.txt,sha256=aeUdGH7UIgMZEMFUc-0xPZWspY95GoPdZcZuLceq85g,361
+q3dviewer-1.1.0.dist-info/top_level.txt,sha256=HFFDCbGu28txcGe2HPc46A7EPaguBa_b5oH7bufmxHM,10
+q3dviewer-1.1.0.dist-info/RECORD,,

{q3dviewer-1.0.8.dist-info → q3dviewer-1.1.0.dist-info}/entry_points.txt

@@ -1,8 +1,8 @@
 [console_scripts]
 cloud_viewer = q3dviewer.tools.cloud_viewer:main
+film_maker = q3dviewer.tools.film_maker:main
 gaussian_viewer = q3dviewer.tools.gaussian_viewer:main
 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
-