q3dviewer 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

q3dviewer/custom_items/image_item.py

@@ -1,169 +0,0 @@
-import pyqtgraph.opengl as gl
-from OpenGL.GL import *
-import numpy as np
-from OpenGL.GL import shaders
-from PIL import Image as PIL_Image
-from PyQt5.QtWidgets import QLabel, QSpinBox
-
-
-# Vertex and Fragment shader source code
-vertex_shader_source = """
-#version 330 core
-layout(location = 0) in vec3 position;
-layout(location = 1) in vec2 texCoord;
-
-out vec2 TexCoord;
-
-uniform mat4 view_matrix;
-uniform mat4 project_matrix;
-
-void main()
-{
-    gl_Position = vec4(position, 1.0);
-    TexCoord = texCoord;
-}
-"""
-
-fragment_shader_source = """
-#version 330 core
-in vec2 TexCoord;
-out vec4 color;
-uniform sampler2D ourTexture;
-void main()
-{
-    color = texture(ourTexture, TexCoord);
-}
-"""
-
-
-def set_uniform_mat4(shader, content, name):
-    content = content.T
-    glUniformMatrix4fv(
-        glGetUniformLocation(shader, name),
-        1,
-        GL_FALSE,
-        content.astype(np.float32)
-    )
-
-
-class ImageItem(gl.GLGraphicsItem.GLGraphicsItem):
-    def __init__(self, pos=np.array([0, 0]), size=np.array([1280/2, 720/2])):
-        gl.GLGraphicsItem.GLGraphicsItem.__init__(self)
-        self.pos = pos  # bottom-left
-        self.size = size
-        self.image = np.zeros((self.size[0], self.size[1], 4), dtype=np.uint8)
-        self.alpha = 255
-
-    def initializeGL(self):
-        # Rectangle vertices and texture coordinates
-        width = self._GLGraphicsItem__view.deviceWidth()
-        height = self._GLGraphicsItem__view.deviceHeight()
-        x0, y0 = self.pos
-        x1, y1 = self.pos + self.size
-        x0 = x0 / width * 2 - 1
-        y0 = y0 / height * 2 - 1
-        x1 = x1 / width * 2 - 1
-        y1 = y1 / height * 2 - 1
-
-        self.vertices = np.array([
-            # positions          # texture coords
-            [x0, y0,  0.0,  0.0, 0.0],  # bottom-left
-            [x1, y0,  0.0,  1.0, 0.0],  # bottom-right
-            [x1,  y1,  0.0,  1.0, 1.0],  # top-right
-            [x0,  y1,  0.0,  0.0, 1.0],   # top-left
-        ], dtype=np.float32)
-
-        indices = np.array([
-            0, 1, 2,  # first triangle
-            2, 3, 0   # second triangle
-        ], dtype=np.uint32)
-
-        self.vao = glGenVertexArrays(1)
-        vbo = glGenBuffers(1)
-        ebo = glGenBuffers(1)
-
-        glBindVertexArray(self.vao)
-
-        glBindBuffer(GL_ARRAY_BUFFER, vbo)
-        glBufferData(GL_ARRAY_BUFFER, self.vertices.itemsize *
-                     5 * 4, self.vertices, GL_STATIC_DRAW)
-
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo)
-        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
-                     indices.nbytes, indices, GL_STATIC_DRAW)
-
-        # Vertex positions
-        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
-                              20, ctypes.c_void_p(0))
-        glEnableVertexAttribArray(0)
-
-        # Texture coordinates
-        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
-                              20, ctypes.c_void_p(12))
-        glEnableVertexAttribArray(1)
-
-        # Compile shaders and create shader program
-        self.program = shaders.compileProgram(
-            shaders.compileShader(vertex_shader_source, GL_VERTEX_SHADER),
-            shaders.compileShader(fragment_shader_source, GL_FRAGMENT_SHADER),
-        )
-
-        self.texture = glGenTextures(1)
-        glBindTexture(GL_TEXTURE_2D, self.texture)
-        glBindVertexArray(0)
-
-    def setData(self, data):
-        if isinstance(data, np.ndarray):
-            pass
-        elif isinstance(data, PIL_Image.Image):
-            data = np.array(data)
-        else:
-            print("not support image type")
-            raise NotImplementedError
-        
-        if data.ndim == 2:  # Grayscale image
-            data = np.stack((data,) * 3 + (np.ones_like(data) * 255,), axis=-1)
-        elif data.shape[-1] == 3:  # RGB image
-            alpha_channel = np.ones((data.shape[0], data.shape[1], 1), dtype=data.dtype) * self.alpha
-            data = np.concatenate((data, alpha_channel), axis=-1)
-        self.image = data
-
-    def paint(self):
-        if self.image is not None:
-            img_data = self.image
-            img_data = np.flipud(img_data)  # Flip the image vertically
-            img_data = img_data.tobytes()
-            glBindTexture(GL_TEXTURE_2D, self.texture)
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.image.shape[1],
-                         self.image.shape[0], 0, GL_RGBA, GL_UNSIGNED_BYTE, img_data)
-            glGenerateMipmap(GL_TEXTURE_2D)
-            glBindTexture(GL_TEXTURE_2D, 0)
-            self.image = None
-
-        glEnable(GL_DEPTH_TEST)
-        glEnable(GL_BLEND)
-        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-
-        glUseProgram(self.program)
-        glBindVertexArray(self.vao)
-        glBindTexture(GL_TEXTURE_2D, self.texture)
-        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, None)
-        glBindTexture(GL_TEXTURE_2D, 0)
-        glBindVertexArray(0)
-        glUseProgram(0)
-
-        glDisable(GL_DEPTH_TEST)
-        glDisable(GL_BLEND)
-
-    def addSetting(self, layout):
-        label1 = QLabel("Set Alpha:")
-        layout.addWidget(label1)
-        box1 = QSpinBox()
-        box1.setSingleStep(1)
-        box1.setRange(0, 255)
-        box1.setValue(self.alpha)
-        box1.valueChanged.connect(self.setAlpha)
-        layout.addWidget(box1)
-
-    def setAlpha(self, alpha):
-        self.alpha = alpha

q3dviewer/custom_items/text_item.py

@@ -1,53 +0,0 @@
-from pyqtgraph.Qt import QtCore
-import pyqtgraph.opengl as gl
-from OpenGL.GL import *
-from PyQt5 import QtGui, QtCore
-
-
-class GL2DTextItem(gl.GLGraphicsItem.GLGraphicsItem):
-    """Draws text over opengl 3D."""
-
-    def __init__(self, **kwds):
-        """All keyword arguments are passed to setData()"""
-        gl.GLGraphicsItem.GLGraphicsItem.__init__(self)
-        glopts = kwds.pop('glOptions', 'additive')
-        self.setGLOptions(glopts)
-        self.pos = (100, 100)
-        self.color = QtCore.Qt.GlobalColor.white
-        self.text = ''
-        self.font = QtGui.QFont('Helvetica', 16)
-        self.setData(**kwds)
-
-    def setData(self, **kwds):
-        args = ['pos', 'color', 'text', 'size', 'font']
-        for k in kwds.keys():
-            if k not in args:
-                raise ValueError('Invalid keyword argument: %s (allowed arguments are %s)' % (k, str(args)))
-        for arg in args:
-            if arg in kwds:
-                value = kwds[arg]
-                if arg == 'pos':
-                    self.pos = value
-                elif arg == 'color':
-                    value = value
-                elif arg == 'font':
-                    if isinstance(value, QtGui.QFont) is False:
-                        raise TypeError('"font" must be QFont.')
-                elif arg == 'size':
-                    self.font.setPointSize(value)
-                setattr(self, arg, value)
-        self.update()
-
-    def paint(self):
-        if len(self.text) < 1:
-            return
-        self.setupGLState()
-
-        text_pos = QtCore.QPointF(*self.pos)
-        painter = QtGui.QPainter(self.view())
-        painter.setPen(self.color)
-        painter.setFont(self.font)
-        painter.setRenderHints(QtGui.QPainter.RenderHint.Antialiasing | QtGui.QPainter.RenderHint.TextAntialiasing)
-        painter.drawText(text_pos, self.text)
-        painter.end()
-

q3dviewer/custom_items/trajectory_item.py

@@ -1,78 +0,0 @@
-import pyqtgraph.opengl as gl
-from OpenGL.GL import *
-import numpy as np
-import threading
-
-
-class TrajectoryItem(gl.GLGridItem):
-    def __init__(self, width=1, color=(0, 1, 0, 1)):
-        super(TrajectoryItem, self).__init__()
-        self.width = width
-        self.buff = np.empty((0, 3), np.float32)
-        self.wait_add_data = None
-        self.mutex = threading.Lock()
-        self.CAPACITY = 100000
-        self.valid_buff_top = 0
-        self.color = color
-
-    def addSetting(self, layout):
-        pass
-
-    def setData(self, data, append=True):
-        self.mutex.acquire()
-        data = data.astype(np.float32).reshape(-1, 3)
-        if (append is False):
-            self.wait_add_data = data
-            self.add_buff_loc = 0
-        else:
-            if (self.wait_add_data is None):
-                self.wait_add_data = data
-            else:
-                self.wait_add_data = np.concatenate([self.wait_add_data, data])
-            self.add_buff_loc = self.valid_buff_top
-        self.mutex.release()
-
-    def updateRenderBuffer(self):
-        if (self.wait_add_data is None):
-            return
-        self.mutex.acquire()
-
-        new_buff_top = self.add_buff_loc + self.wait_add_data.shape[0]
-        if new_buff_top > self.buff.shape[0]:
-            buff_capacity = self.buff.shape[0]
-            while (new_buff_top > buff_capacity):
-                buff_capacity += self.CAPACITY
-            self.buff = np.empty((buff_capacity, 3), np.float32)
-            self.buff[self.add_buff_loc:new_buff_top] = self.wait_add_data
-            glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
-            glBufferData(GL_ARRAY_BUFFER, self.buff.nbytes,
-                         self.buff, GL_DYNAMIC_DRAW)
-            glBindBuffer(GL_ARRAY_BUFFER, 0)
-        else:
-            self.buff[self.add_buff_loc:new_buff_top] = self.wait_add_data
-            glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
-            glBufferSubData(GL_ARRAY_BUFFER, self.add_buff_loc * 12,
-                            self.wait_add_data.shape[0] * 12, self.wait_add_data)
-        self.valid_buff_top = new_buff_top
-        self.wait_add_data = None
-        self.mutex.release()
-
-    def initializeGL(self):
-        self.vbo = glGenBuffers(1)
-
-    def paint(self):
-        self.setupGLState()
-        self.updateRenderBuffer()
-        glEnable(GL_BLEND)
-        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
-        glEnableClientState(GL_VERTEX_ARRAY)
-        glVertexPointer(3, GL_FLOAT, 0, None)
-        glLineWidth(self.width)
-        glColor4f(*self.color)  # z is blue
-
-        glDrawArrays(GL_LINE_STRIP, 0, self.valid_buff_top)
-        glDisableClientState(GL_VERTEX_ARRAY)
-
-        glBindBuffer(GL_ARRAY_BUFFER, 0)
-        glUseProgram(0)

q3dviewer/gau_io.py

@@ -1,168 +0,0 @@
-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/tools/__init__.py

@@ -1,6 +0,0 @@
-from q3dviewer.tools.cloud_viewer import main as cloud_viewer
-from q3dviewer.tools.ros_viewer import main as ros_viewer
-from q3dviewer.tools.mesh_viewer import main as mesh_viewer
-from q3dviewer.tools.gaussian_viewer import main as gaussian_viewer
-from q3dviewer.tools.lidar_cam_calib import main as lidar_cam_calib
-from q3dviewer.tools.lidar_calib import main as lidar_calib

q3dviewer/tools/cloud_viewer.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-
-import numpy as np
-from pypcd4 import PointCloud
-import q3dviewer as q3d
-
-
-class CloudViewer(q3d.Viewer):
-    def __init__(self, **kwargs):
-        super(CloudViewer, self).__init__(**kwargs)
-        self.setAcceptDrops(True)
-
-    def dragEnterEvent(self, event):
-        if event.mimeData().hasUrls():
-            event.accept()
-        else:
-            event.ignore()
-
-    def dropEvent(self, event):
-        for url in event.mimeData().urls():
-            file_path = url.toLocalFile()
-            self.openCloudFile(file_path)
-
-    def openCloudFile(self, file):
-        cloud_item = self['cloud']
-        if cloud_item is None:
-            print("Can't find clouditem.")
-            return
-        if file.endswith('.pcd'):
-            pc = PointCloud.from_path(file).pc_data
-            if 'rgb' in pc.dtype.names:
-                color = pc["rgb"].astype(np.uint32)
-                cloud_item.setColorMode('RGB')
-            elif 'intensity' in pc.dtype.names:
-                color = pc["intensity"].astype(np.uint32)
-                cloud_item.setColorMode('I')
-            else:
-                color = pc['z'].astype(np.uint32)
-                cloud_item.setColorMode('#FFFFFF')
-            cloud = np.rec.fromarrays(
-                [np.stack([pc["x"], pc["y"], pc["z"]], axis=1), color],
-                dtype=cloud_item.data_type)
-        elif file.endswith('.npy'):
-            pc = np.load(file)
-            cloud = np.rec.fromarrays(
-                [np.stack([pc[:, 0], pc[:, 1], pc[:, 2]], axis=1),
-                 pc[:, 3].astype(np.uint32)],
-                dtype=cloud_item.data_type)
-        cloud_item.setData(data=cloud)
-
-
-def main():
-    import argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--pcd", help="the pcd path")
-    args = parser.parse_args()
-    app = q3d.QApplication(['Cloud Viewer'])
-    viewer = CloudViewer(name='Cloud Viewer')
-    cloud_item = q3d.CloudIOItem(size=1, alpha=0.1)
-    axis_item = q3d.GLAxisItem(size=0.5, width=5)
-    grid_item = q3d.GridItem(size=1000, spacing=20)
-
-    viewer.addItems(
-        {'cloud': cloud_item, 'grid': grid_item, 'axis': axis_item})
-
-    if args.pcd:
-        pcd_fn = args.pcd
-        viewer.openCloudFile(pcd_fn)
-
-    viewer.show()
-    app.exec_()
-
-
-if __name__ == '__main__':
-    main()

q3dviewer/tools/example_viewer.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-
-import numpy as np
-import threading
-import time
-import q3dviewer as q3d
-
-
-def update(viewer):
-    i = 0.0
-    while True:
-        i += 0.05
-        time.sleep(0.1)
-        viewer['traj'].setData(np.array([np.sin(i) * i, np.cos(i) * i, i]))
-
-
-def main():
-    app = q3d.QApplication([])
-
-    axis_item = q3d.GLAxisItem(size=0.5, width=5)
-    grid_item = q3d.GridItem(size=10, spacing=1)
-    traj_item = q3d.TrajectoryItem(width=2)
-
-    viewer = q3d.Viewer(name='example')
-    th = threading.Thread(target=update, args=(viewer, ))
-    th.start()
-
-    viewer.addItems({
-        'grid': grid_item,
-        'axis': axis_item,
-        'traj': traj_item})
-
-    viewer.show()
-    app.exec_()
-
-
-if __name__ == '__main__':
-    main()

q3dviewer/tools/gaussian_viewer.py

@@ -1,55 +0,0 @@
-#!/usr/bin/env python3
-
-import numpy as np
-import q3dviewer as q3d
-from q3dviewer.gau_io import load_gs, rotate_gaussian
-
-
-class GuassianViewer(q3d.Viewer):
-    def __init__(self):
-        super(GuassianViewer, self).__init__(name="Guassian Viewer")
-        self.setAcceptDrops(True)
-
-    def dragEnterEvent(self, event):
-        if event.mimeData().hasUrls():
-            event.accept()
-        else:
-            event.ignore()
-
-    def dropEvent(self, event):
-        for url in event.mimeData().urls():
-            file_path = url.toLocalFile()
-            self.openGuassianFile(file_path)
-
-    def openGuassianFile(self, file):
-        gau_item = self['gaussian']
-        if gau_item is None:
-            print("Can't find gaussianitem")
-            return
-
-        print("Try to load %s ..." % file)
-        gs = load_gs(file)
-        # convert camera optical frame (b) to camera frame (c).
-        Rcb = np.array([[0, -1, 0],
-                        [0, 0, -1],
-                        [1, 0, 0]]).T
-        gs = rotate_gaussian(Rcb, gs)
-        gs_data = gs.view(np.float32).reshape(gs.shape[0], -1)
-        gau_item.setData(gs_data=gs_data)
-
-
-def main():
-    app = q3d.QApplication(['Guassian Viewer'])
-    viewer = GuassianViewer(name='Guassian Viewer')
-
-    grid_item = q3d.GridItem(size=1000, spacing=20)
-    gau_item = q3d.GaussianItem()
-
-    viewer.addItems({'grid': grid_item, 'gaussian': gau_item})
-
-    viewer.show()
-    app.exec_()
-
-
-if __name__ == '__main__':
-    main()