q3dviewer 1.0.0__py3-none-any.whl

q3dviewer/gau_io.py

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

q3dviewer/utils.py

@@ -0,0 +1,146 @@
+import numpy as np
+import time
+
+
+def rainbow(scalars, scalar_min=0, scalar_max=255):
+    range = scalar_max - scalar_min
+    values = 1.0 - (scalars - scalar_min) / range
+    # values = (scalars - scalar_min) / range  # using inverted color
+    colors = np.zeros([scalars.shape[0], 3], dtype=np.float32)
+    values = np.clip(values, 0, 1)
+
+    h = values * 5.0 + 1.0
+    i = np.floor(h).astype(int)
+    f = h - i
+    f[np.logical_not(i % 2)] = 1 - f[np.logical_not(i % 2)]
+    n = 1 - f
+
+    # idx = i <= 1
+    colors[i <= 1, 0] = n[i <= 1] * 255
+    colors[i <= 1, 1] = 0
+    colors[i <= 1, 2] = 255
+
+    colors[i == 2, 0] = 0
+    colors[i == 2, 1] = n[i == 2] * 255
+    colors[i == 2, 2] = 255
+
+    colors[i == 3, 0] = 0
+    colors[i == 3, 1] = 255
+    colors[i == 3, 2] = n[i == 3] * 255
+
+    colors[i == 4, 0] = n[i == 4] * 255
+    colors[i == 4, 1] = 255
+    colors[i == 4, 2] = 0
+
+    colors[i >= 5, 0] = 255
+    colors[i >= 5, 1] = n[i >= 5] * 255
+    colors[i >= 5, 2] = 0
+    return colors
+
+
+def euler_to_matrix(rpy):
+    roll, pitch, yaw = rpy
+    Rx = np.array([[1, 0, 0],
+                   [0, np.cos(roll), -np.sin(roll)],
+                   [0, np.sin(roll), np.cos(roll)]])
+    Ry = np.array([[np.cos(pitch), 0, np.sin(pitch)],
+                   [0, 1, 0],
+                   [-np.sin(pitch), 0, np.cos(pitch)]])
+    Rz = np.array([[np.cos(yaw), -np.sin(yaw), 0],
+                   [np.sin(yaw), np.cos(yaw), 0],
+                   [0, 0, 1]])
+    R = Rz @ Ry @ Rx
+    return R
+
+
+def matrix_to_euler(R):
+    sy = np.sqrt(R[0, 0]**2 + R[1, 0]**2)
+    singular = sy < 1e-6  # Check for gimbal lock
+    if not singular:
+        roll = np.arctan2(R[2, 1], R[2, 2])   # X-axis rotation
+        pitch = np.arctan2(-R[2, 0], sy)      # Y-axis rotation
+        yaw = np.arctan2(R[1, 0], R[0, 0])    # Z-axis rotation
+    else:
+        # Gimbal lock case
+        roll = np.arctan2(-R[1, 2], R[1, 1])
+        pitch = np.arctan2(-R[2, 0], sy)
+        yaw = 0  # Arbitrarily set yaw to 0
+
+    return np.array([roll, pitch, yaw])
+
+
+def matrix_to_quaternion(matrix):
+    trace = matrix[0, 0] + matrix[1, 1] + matrix[2, 2]
+    if trace > 0:
+        s = 0.5 / np.sqrt(trace + 1.0)
+        w = 0.25 / s
+        x = (matrix[2, 1] - matrix[1, 2]) * s
+        y = (matrix[0, 2] - matrix[2, 0]) * s
+        z = (matrix[1, 0] - matrix[0, 1]) * s
+    else:
+        if matrix[0, 0] > matrix[1, 1] and matrix[0, 0] > matrix[2, 2]:
+            s = 2.0 * np.sqrt(1.0 + matrix[0, 0] - matrix[1, 1] - matrix[2, 2])
+            w = (matrix[2, 1] - matrix[1, 2]) / s
+            x = 0.25 * s
+            y = (matrix[0, 1] + matrix[1, 0]) / s
+            z = (matrix[0, 2] + matrix[2, 0]) / s
+        elif matrix[1, 1] > matrix[2, 2]:
+            s = 2.0 * np.sqrt(1.0 + matrix[1, 1] - matrix[0, 0] - matrix[2, 2])
+            w = (matrix[0, 2] - matrix[2, 0]) / s
+            x = (matrix[0, 1] + matrix[1, 0]) / s
+            y = 0.25 * s
+            z = (matrix[1, 2] + matrix[2, 1]) / s
+        else:
+            s = 2.0 * np.sqrt(1.0 + matrix[2, 2] - matrix[0, 0] - matrix[1, 1])
+            w = (matrix[1, 0] - matrix[0, 1]) / s
+            x = (matrix[0, 2] + matrix[2, 0]) / s
+            y = (matrix[1, 2] + matrix[2, 1]) / s
+            z = 0.25 * s
+    return np.array([x, y, z, w])
+
+
+def quaternion_to_matrix(quaternion):
+    x, y, z, w = quaternion
+    q = np.array(quaternion[:4], dtype=np.float64, copy=True)
+    n = np.linalg.norm(q)
+    if np.any(n == 0.0):
+        raise ZeroDivisionError("bad quaternion input")
+    else:
+        m = np.empty((3, 3))
+        m[0, 0] = 1.0 - 2*(y**2 + z**2)/n
+        m[0, 1] = 2*(x*y - z*w)/n
+        m[0, 2] = 2*(x*z + y*w)/n
+        m[1, 0] = 2*(x*y + z*w)/n
+        m[1, 1] = 1.0 - 2*(x**2 + z**2)/n
+        m[1, 2] = 2*(y*z - x*w)/n
+        m[2, 0] = 2*(x*z - y*w)/n
+        m[2, 1] = 2*(y*z + x*w)/n
+        m[2, 2] = 1.0 - 2*(x**2 + y**2)/n
+        return m
+
+
+def make_transform(pose, rotation):
+    transform = np.eye(4)
+    transform[0:3, 0:3] = quaternion_to_matrix(rotation)
+    transform[0:3, 3] = pose
+    return transform
+
+
+class FPSMonitor():
+    def __init__(self):
+        self.stamp_record = []
+
+    def count(self):
+        cur_stamp = time.time()
+        self.stamp_record.append(cur_stamp)
+        while len(self.stamp_record) > 0:
+            if(cur_stamp - self.stamp_record[0] > 1.):
+                self.stamp_record.pop(0)
+            else:
+                break
+        return len(self.stamp_record)
+
+
+# euler = np.array([1, 0.1, 0.1])
+# euler_angles = matrix_to_euler(euler_to_matrix(euler))
+# print("Euler Angles:", euler_angles)

q3dviewer/viewer_widget.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import pyqtgraph.opengl as gl
+from pyqtgraph.Qt import QtCore
+from PyQt5.QtWidgets import QWidget, QComboBox, QVBoxLayout, QHBoxLayout, \
+    QSizePolicy, QSpacerItem, QMainWindow
+from OpenGL.GL import *
+from PyQt5.QtGui import QKeyEvent, QVector3D
+from PyQt5.QtWidgets import QApplication, QWidget
+import numpy as np
+from PyQt5.QtWidgets import QLabel, QLineEdit, \
+    QDoubleSpinBox, QSpinBox, QCheckBox
+
+
+class SettingWindow(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.combo_items = QComboBox()
+        self.combo_items.currentIndexChanged.connect(self.onComboboxSelection)
+        main_layout = QVBoxLayout()
+        self.stretch = QSpacerItem(
+            10, 10, QSizePolicy.Minimum, QSizePolicy.Expanding)
+        main_layout.addWidget(self.combo_items)
+        self.layout = QVBoxLayout()
+        self.layout.addItem(self.stretch)
+        main_layout.addLayout(self.layout)
+        self.setLayout(main_layout)
+        self.setWindowTitle("Setting Window")
+        self.setGeometry(200, 200, 300, 200)
+        self.items = {}
+
+    def addSetting(self, name, item):
+        self.items.update({name: item})
+        self.combo_items.addItem("%s(%s)" % (name, item.__class__.__name__))
+
+    def clearSetting(self):
+        while self.layout.count():
+            child = self.layout.takeAt(0)
+            if child.widget():
+                child.widget().deleteLater()
+
+    def onComboboxSelection(self, index):
+        self.layout.removeItem(self.stretch)
+        # remove all setting of previous widget
+        self.clearSetting()
+
+        key = list(self.items.keys())
+        try:
+            item = self.items[key[index]]
+            item.addSetting(self.layout)
+            self.layout.addItem(self.stretch)
+        except AttributeError:
+            print("%s: No setting." % (item.__class__.__name__))
+
+
+class ViewWidget(gl.GLViewWidget):
+    def __init__(self):
+        self.followed_name = 'none'
+        self.named_items = {}
+        self.color = '#000000'
+        self.followable_item_name = ['none']
+        self.setting_window = SettingWindow()
+        super(ViewWidget, self).__init__()
+
+    def onFollowableSelection(self, index):
+        self.followed_name = self.followable_item_name[index]
+
+    def update(self):
+        if self.followed_name != 'none':
+            pos = self.named_items[self.followed_name].T[:3, 3]
+            self.opts['center'] = QVector3D(pos[0], pos[1], pos[2])
+        super().update()
+
+    def addSetting(self, layout):
+        label1 = QLabel("Set background color:")
+        label1.setToolTip("using '#xxxxxx', i.e. #FF4500")
+        box1 = QLineEdit()
+        box1.setToolTip("'using '#xxxxxx', i.e. #FF4500")
+        box1.setText(str(self.color))
+        box1.textChanged.connect(self.setBKColor)
+        layout.addWidget(label1)
+        layout.addWidget(box1)
+        label2 = QLabel("Set Focus:")
+        combo2 = QComboBox()
+        for name in self.followable_item_name:
+            combo2.addItem(name)
+        combo2.currentIndexChanged.connect(self.onFollowableSelection)
+        layout.addWidget(label2)
+        layout.addWidget(combo2)
+
+    def setBKColor(self, color):
+        if (type(color) != str):
+            return
+        if color.startswith("#"):
+            try:
+                self.setBackgroundColor(color)
+                self.color = color
+            except ValueError:
+                return
+
+    def addItem(self, name, item):
+        self.named_items.update({name: item})
+        if (item.__class__.__name__ == 'GLAxisItem'):
+            self.followable_item_name.append(name)
+        self.setting_window.addSetting(name, item)
+        super().addItem(item)
+
+    def mouseReleaseEvent(self, ev):
+        if hasattr(self, 'mousePos'):
+            delattr(self, 'mousePos')
+
+    def mouseMoveEvent(self, ev):
+        lpos = ev.localPos()
+        if not hasattr(self, 'mousePos'):
+            self.mousePos = lpos
+        diff = lpos - self.mousePos
+        self.mousePos = lpos
+        if ev.buttons() == QtCore.Qt.MouseButton.RightButton:
+            self.orbit(-diff.x(), diff.y())
+        elif ev.buttons() == QtCore.Qt.MouseButton.LeftButton:
+            pitch_abs = np.abs(self.opts['elevation'])
+            camera_mode = 'view-upright'
+            if (pitch_abs <= 45.0 or pitch_abs == 90):
+                camera_mode = 'view'
+            self.pan(diff.x(), diff.y(), 0, relative=camera_mode)
+
+    def keyPressEvent(self, ev: QKeyEvent):
+        step = 10
+        zoom_delta = 20
+        speed = 2
+        self.projectionMatrix().data()
+
+        pitch_abs = np.abs(self.opts['elevation'])
+        camera_mode = 'view-upright'
+        if (pitch_abs <= 45.0 or pitch_abs == 90):
+            camera_mode = 'view'
+
+        if ev.key() == QtCore.Qt.Key_M:  # setting meun
+            print("Open setting windows")
+            self.openSettingWindow()
+        elif ev.key() == QtCore.Qt.Key_R:
+            print("Clear viewer")
+            for item in self.named_items.values():
+                try:
+                    item.clear()
+                except AttributeError:
+                    pass
+        elif ev.key() == QtCore.Qt.Key_Up:
+            if ev.modifiers() & QtCore.Qt.KeyboardModifier.ControlModifier:
+                self.pan(0, +step, 0, relative=camera_mode)
+            else:
+                self.orbit(azim=0, elev=-speed)
+        elif ev.key() == QtCore.Qt.Key_Down:
+            if ev.modifiers() & QtCore.Qt.KeyboardModifier.ControlModifier:
+                self.pan(0, -step, 0, relative=camera_mode)
+            else:
+                self.orbit(azim=0, elev=speed)
+        elif ev.key() == QtCore.Qt.Key_Left:
+            if ev.modifiers() & QtCore.Qt.KeyboardModifier.ControlModifier:
+                self.pan(+step, 0, 0, relative=camera_mode)
+            else:
+                self.orbit(azim=speed, elev=0)
+
+        elif ev.key() == QtCore.Qt.Key_Right:
+            if ev.modifiers() & QtCore.Qt.KeyboardModifier.ControlModifier:
+                self.pan(-step, 0, 0, relative=camera_mode)
+            else:
+                self.orbit(azim=-speed, elev=0)
+
+        elif ev.key() == QtCore.Qt.Key_Z:
+            self.opts['distance'] *= 0.999**(+zoom_delta)
+        elif ev.key() == QtCore.Qt.Key_X:
+            self.opts['distance'] *= 0.999**(-zoom_delta)
+        else:
+            super().keyPressEvent(ev)
+
+    def openSettingWindow(self):
+        if self.setting_window.isVisible():
+            self.setting_window.raise_()
+
+        else:
+            self.setting_window.show()

q3dviewer-1.0.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: q3dviewer
+Version: 1.0.0
+Requires-Dist: numpy
+Requires-Dist: pyqtgraph
+Requires-Dist: pyqt5
+Requires-Dist: PyOpenGL
+Requires-Dist: pypcd4
+Requires-Dist: pillow
+

q3dviewer-1.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+q3dviewer/__init__.py,sha256=BCrGWEtwjdvK4CHgp1e5Wkyhabk6WdvY_7FKJdGJwGE,142
+q3dviewer/basic_viewer.py,sha256=A7bMxutP1grnqE5A4tjODGrzNfFq6-c6MlNYj8t54WU,1609
+q3dviewer/gau_io.py,sha256=fKry1eyeFdw_JO5JZqU3l66dzt43NGpHhX89ER_y38A,5900
+q3dviewer/utils.py,sha256=xzUAXUhgxoJyPrnivnyrJWoQQg9LrDPhxgZo1Cp35kQ,4596
+q3dviewer/viewer_widget.py,sha256=repcGWZZXRxua8C-3CYHumvkVoPQl8ycFPTBx5zovRg,6561
+q3dviewer/custom_items/__init__.py,sha256=Isb3HPtymuxEev1hc81x51inzH6epomtBHBQsPp4gZY,446
+q3dviewer/custom_items/axis_item.py,sha256=Er8HRSnOscROZ7fOZEESnrZp62A5kY4oqP-GCAXczYU,2353
+q3dviewer/custom_items/camera_frame_item.py,sha256=hvpZ3UEnkbs1nHNr2R7huuy1MdvBmwQPiqqKImWWG8c,5622
+q3dviewer/custom_items/cloud_io_item.py,sha256=nbZbZLX72CWNFrInpxwysA2usbCkgAUrwZEOOVWx9Mc,2816
+q3dviewer/custom_items/cloud_item.py,sha256=gOIun2VOfarA4Xo_2vdyWpIII0vvWVcQ4VqCZsYj584,9711
+q3dviewer/custom_items/gaussian_item.py,sha256=3YXdJxHNSdk0D2HS2VJvuGTUjbi9D_UcrWEXSzxP7BY,10177
+q3dviewer/custom_items/grid_item.py,sha256=WuNzIHBhjAQ6e4fP5aBp5jSgYbrY7wrbP9PhRptuz7s,1150
+q3dviewer/custom_items/image_item.py,sha256=qOT0r6p8_NcF5GVeJrrR8rJNe68U_jW1qrUDZ05O5hI,5312
+q3dviewer/custom_items/text_item.py,sha256=lbJaXfpeyyxr6lhlMjypk4a079-aUpsrXFjGi-BTzPU,1872
+q3dviewer/custom_items/trajectory_item.py,sha256=9gM5voiYk0j4JMEp3drF7VFYSPsJcEK7mibdx45OQDs,2778
+q3dviewer-1.0.0.dist-info/METADATA,sha256=YkgPKWnfC-R9Q26DXkrAwih_KwyqAeAPVbOgzRwiMIk,189
+q3dviewer-1.0.0.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+q3dviewer-1.0.0.dist-info/entry_points.txt,sha256=6zSxtJ5cjcpc32sR_wkRqOaeiJFpEuLnJQckZE3niU0,316
+q3dviewer-1.0.0.dist-info/top_level.txt,sha256=HFFDCbGu28txcGe2HPc46A7EPaguBa_b5oH7bufmxHM,10
+q3dviewer-1.0.0.dist-info/RECORD,,

q3dviewer-1.0.0.dist-info/WHEEL

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

q3dviewer-1.0.0.dist-info/entry_points.txt

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

q3dviewer-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+q3dviewer