q3dviewer 1.0.0__py3-none-any.whl

q3dviewer/__init__.py

@@ -0,0 +1,4 @@
+from q3dviewer.utils import *
+from q3dviewer.custom_items import *
+from q3dviewer.viewer_widget import *
+from q3dviewer.basic_viewer import *

q3dviewer/basic_viewer.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+
+from q3dviewer.viewer_widget import *
+import signal
+import sys
+
+
+def handler(signal, frame):
+    QApplication.quit()
+    print("Force close by Ctrl+C")
+
+
+class Viewer(QMainWindow):
+    def __init__(self, name='Viewer', win_size=[1920, 1080], vw=ViewWidget):
+        signal.signal(signal.SIGINT, handler)
+        super(Viewer, self).__init__()
+        self.vw = vw
+        self.setGeometry(0, 0, win_size[0], win_size[1])
+        self.initUI()
+        self.setWindowTitle(name)
+
+    def initUI(self):
+        centerWidget = QWidget()
+        self.setCentralWidget(centerWidget)
+        layout = QVBoxLayout()
+        centerWidget.setLayout(layout)
+        self.viewerWidget = self.vw()
+        layout.addWidget(self.viewerWidget, 1)
+        timer = QtCore.QTimer(self)
+        timer.setInterval(20)  # period, in milliseconds
+        timer.timeout.connect(self.update)
+        self.viewerWidget.setCameraPosition(distance=40)
+        timer.start()
+
+    def addItems(self, named_items: dict):
+        for name, item in named_items.items():
+            self.viewerWidget.addItem(name, item)
+
+    def __getitem__(self, name: str):
+        if name in self.viewerWidget.named_items:
+            return self.viewerWidget.named_items[name]
+        else:
+            return None
+
+    def update(self):
+        # force update by timer
+        self.viewerWidget.update()
+
+    def closeEvent(self, event):
+        event.accept()
+        QApplication.quit()
+
+    def show(self):
+        self.viewerWidget.setting_window.addSetting(
+            "main win", self.viewerWidget)
+        super().show()

q3dviewer/custom_items/__init__.py

@@ -0,0 +1,9 @@
+from q3dviewer.custom_items.axis_item import *
+from q3dviewer.custom_items.cloud_item import *
+from q3dviewer.custom_items.cloud_io_item import *
+from q3dviewer.custom_items.gaussian_item import *
+from q3dviewer.custom_items.camera_frame_item import *
+from q3dviewer.custom_items.grid_item import *
+from q3dviewer.custom_items.text_item import *
+from q3dviewer.custom_items.image_item import *
+from q3dviewer.custom_items.trajectory_item import *

q3dviewer/custom_items/axis_item.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import pyqtgraph.opengl as gl
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from OpenGL.GLUT import *
+import numpy as np
+from PyQt5.QtWidgets import QLabel, QDoubleSpinBox
+
+
+class GLAxisItem(gl.GLGraphicsItem.GLGraphicsItem):
+    def __init__(self, size=1., width=5, glOptions='translucent'):
+        gl.GLGraphicsItem.GLGraphicsItem.__init__(self)
+        self.size = size
+        self.width = width
+        self.org = np.array([0, 0, 0, 1])
+        self.axis_x = np.array([self.size, 0, 0, 1])
+        self.axis_y = np.array([0, self.size, 0, 1])
+        self.axis_z = np.array([0, 0, self.size, 1])
+        self.setGLOptions(glOptions)
+        self.T = np.eye(4)
+        self.settings = []
+
+    def addSetting(self, layout):
+        label1 = QLabel("Set size:")
+        layout.addWidget(label1)
+        box1 = QDoubleSpinBox()
+        box1.setSingleStep(0.1)
+        layout.addWidget(box1)
+        box1.setValue(self.size)
+        box1.valueChanged.connect(self.setSize)
+        box1.setRange(0.0, 100)
+
+        label2 = QLabel("Set Width:")
+        layout.addWidget(label2)
+        box2 = QDoubleSpinBox()
+        layout.addWidget(box2)
+        box2.setSingleStep(0.1)
+        box2.setValue(self.width)
+        box2.valueChanged.connect(self.setWidth)
+        box2.setRange(0, 1000)
+
+    def setSize(self, size):
+        self.size = size
+        self.axis_x = np.array([self.size, 0, 0, 1])
+        self.axis_y = np.array([0, self.size, 0, 1])
+        self.axis_z = np.array([0, 0, self.size, 1])
+
+    def setWidth(self, width):
+        self.width = width
+
+    def setTransform(self, T):
+        self.T = T
+
+    def paint(self):
+        org = self.T.dot(self.org)
+        axis_x = self.T.dot(self.axis_x)
+        axis_y = self.T.dot(self.axis_y)
+        axis_z = self.T.dot(self.axis_z)
+        self.setupGLState()
+        glLineWidth(self.width)
+        glBegin(GL_LINES)
+        glColor4f(0, 0, 1, 1)  # z is blue
+        glVertex3f(org[0], org[1], org[2])
+        glVertex3f(axis_z[0], axis_z[1], axis_z[2])
+        glColor4f(0, 1, 0, 1)  # y is green
+        glVertex3f(org[0], org[1], org[2])
+        glVertex3f(axis_y[0], axis_y[1], axis_y[2])
+        glColor4f(1, 0, 0, 1)  # x is red
+        glVertex3f(org[0], org[1], org[2])
+        glVertex3f(axis_x[0], axis_x[1], axis_x[2])
+        glEnd()

q3dviewer/custom_items/camera_frame_item.py

@@ -0,0 +1,173 @@
+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
+
+
+# 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 = project_matrix * view_matrix * 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 GLCameraFrameItem(gl.GLGraphicsItem.GLGraphicsItem):
+    def __init__(self, T=np.eye(4), size=1, width=3, path=None):
+        gl.GLGraphicsItem.GLGraphicsItem.__init__(self)
+        self.size = size
+        self.width = width
+        self.T = T
+        self.path = path
+
+    def initializeGL(self):
+        # Rectangle vertices and texture coordinates
+        hsize = self.size / 2
+        self.vertices = np.array([
+            # positions          # texture coords
+            [-hsize, -hsize,  0.0,  0.0, 0.0],  # bottom-left
+            [hsize, -hsize,  0.0,  1.0, 0.0],  # bottom-right
+            [hsize,  hsize,  0.0,  1.0, 1.0],  # top-right
+            [-hsize,  hsize,  0.0,  0.0, 1.0],   # top-left
+            [0,  0, -hsize * 0.66, 0.0, 0.0],   # top-left
+        ], dtype=np.float32)
+
+        R = self.T[:3, :3]
+        t = self.T[:3, 3]
+        self.vertices[:, :3] = (
+            R @ self.vertices[:, :3].T + t[:, np.newaxis]).T
+
+        self.focal_p = np.array([0, 0, hsize * 0.66])
+
+        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)
+
+        project_matrix = np.array(self._GLGraphicsItem__view.projectionMatrix().data(),
+                                  np.float32).reshape([4, 4]).T
+        # 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),
+        )
+        glUseProgram(self.program)
+        set_uniform_mat4(self.program, project_matrix, 'project_matrix')
+        glUseProgram(0)
+
+        self.texture = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, self.texture)
+
+        # Load image
+        image = PIL_Image.open(self.path)
+        # image = image.transpose(Image.FLIP_TOP_BOTTOM)
+        img_data = image.convert("RGBA").tobytes()
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width,
+                     image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, img_data)
+        glGenerateMipmap(GL_TEXTURE_2D)
+        glBindTexture(GL_TEXTURE_2D, 0)
+        glBindVertexArray(0)
+
+    def setTransform(self, T):
+        self.T = T
+
+    def paint(self):
+        self.view_matrix = np.array(
+            self._GLGraphicsItem__view.viewMatrix().data(), np.float32).reshape([4, 4]).T
+        project_matrix = np.array(self._GLGraphicsItem__view.projectionMatrix(
+        ).data(), np.float32).reshape([4, 4]).T
+
+        glEnable(GL_DEPTH_TEST)
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+
+        glUseProgram(self.program)
+        set_uniform_mat4(self.program, self.view_matrix, 'view_matrix')
+        set_uniform_mat4(self.program, project_matrix, 'project_matrix')
+        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)
+
+        glLineWidth(self.width)
+        glBegin(GL_LINES)
+        glColor4f(1, 1, 1, 1)  # z is blue
+        glVertex3f(*self.vertices[0, :3])
+        glVertex3f(*self.vertices[1, :3])
+        glVertex3f(*self.vertices[1, :3])
+        glVertex3f(*self.vertices[2, :3])
+        glVertex3f(*self.vertices[2, :3])
+        glVertex3f(*self.vertices[3, :3])
+        glVertex3f(*self.vertices[3, :3])
+        glVertex3f(*self.vertices[0, :3])
+        glVertex3f(*self.vertices[4, :3])
+        glVertex3f(*self.vertices[0, :3])
+        glVertex3f(*self.vertices[4, :3])
+        glVertex3f(*self.vertices[1, :3])
+        glVertex3f(*self.vertices[4, :3])
+        glVertex3f(*self.vertices[2, :3])
+        glVertex3f(*self.vertices[4, :3])
+        glVertex3f(*self.vertices[3, :3])
+        glEnd()
+
+        glDisable(GL_DEPTH_TEST)
+        glDisable(GL_BLEND)

q3dviewer/custom_items/cloud_io_item.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+
+from q3dviewer.custom_items.cloud_item import CloudItem
+from pypcd4 import PointCloud, MetaData
+from pathlib import Path
+import os
+from PyQt5.QtWidgets import QPushButton, QLabel, QLineEdit, QMessageBox
+import numpy as np
+
+
+class CloudIOItem(CloudItem):
+    """
+    add save/load function to CloudItem
+    """
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.save_path = str(Path(os.getcwd(), "data.pcd"))
+
+    def addSetting(self, layout):
+        super().addSetting(layout)
+
+        label4 = QLabel("Save Path:")
+        layout.addWidget(label4)
+        box4 = QLineEdit()
+        box4.setText(self.save_path)
+        box4.textChanged.connect(self.setPath)
+        layout.addWidget(box4)
+        save_button = QPushButton("Save Cloud")
+        save_button.clicked.connect(self.save)
+        layout.addWidget(save_button)
+
+    def save(self):
+        cloud = self.buff[:self.valid_buff_top]
+        if self.save_path.endswith(".pcd"):
+            fields = ("x", "y", "z", "rgb")
+            metadata = MetaData.model_validate(
+                {
+                    "fields": fields,
+                    "size": [4, 4, 4, 4],
+                    "type": ['F', 'F', 'F', 'U'],
+                    "count": [1, 1, 1, 1],
+                    "width": cloud.shape[0],
+                    "points": cloud.shape[0],
+                })
+            pc = PointCloud(metadata, cloud)
+            try:
+                pc.save(self.save_path)
+                save_msg = QMessageBox()
+                save_msg.setIcon(QMessageBox.Information)
+                save_msg.setWindowTitle("save")
+                save_msg.setStandardButtons(QMessageBox.Ok)
+                save_msg.setText("save cloud to  %s" % self.save_path)
+            except:
+                save_msg.setText("Cannot save to %s" % self.save_path)
+            save_msg.exec()
+
+        elif self.save_path.endswith(".ply"):
+            print("Not implment yet!")
+        else:
+            print("Not supported cloud file type!")
+
+    def load(self, file):
+            print("Try to load %s ..." % file)
+            pc = PointCloud.from_path(file).pc_data
+
+            try:
+                color = pc["rgb"].astype(np.uint32)
+                self.setColorMode('RGB')
+            except ValueError:
+                try:
+                    color = pc["intensity"].astype(np.uint32)
+                    self.setColorMode('I')
+                except ValueError:
+                    color = pc['z'].astype(np.uint32)
+                    self.setColorMode('#FFFFFF')
+
+            cloud = np.rec.fromarrays(
+                [np.stack([pc["x"], pc["y"], pc["z"]], axis=1), color],
+                dtype=self.data_type)
+            self.setData(data=cloud)
+
+    def setPath(self, path):
+        self.save_path = path

q3dviewer/custom_items/cloud_item.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import pyqtgraph.opengl as gl
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from OpenGL.GLUT import *
+import numpy as np
+import threading
+from PyQt5.QtWidgets import QLabel, QLineEdit, QDoubleSpinBox, QSpinBox
+from PyQt5.QtGui import QValidator
+from OpenGL.GL import shaders
+
+
+vertex_shader = """
+#version 330 core
+
+layout (location = 0) in vec3 position;
+layout (location = 1) in uint value;
+
+uniform mat4 view_matrix;
+uniform mat4 projection_matrix;
+uniform float alpha;
+uniform int color_mode;
+uniform float vmin = 0;
+uniform float vmax = 255;
+out vec4 color;
+
+vec3 getRainbowColor(uint value_raw) {
+    // Normalize value to [0, 1]
+    float range = vmax - vmin;
+    float value = 1.0 - (float(value_raw) - vmin) / range;
+    value = clamp(value, 0.0, 1.0);
+    // Convert value to hue in the range [0, 1]
+    float hue = value * 5.0 + 1.0;
+    int i = int(floor(hue));
+    float f = hue - float(i);
+    if (mod(i, 2) == 0) f = 1.0 - f; // if i is even
+    float n = 1.0 - f;
+
+    // Determine RGB components based on hue value
+    vec3 color;
+    if (i <= 1) color = vec3(n, 0.0, 1.0);
+    else if (i == 2) color = vec3(0.0, n, 1.0);
+    else if (i == 3) color = vec3(0.0, 1.0, n);
+    else if (i == 4) color = vec3(n, 1.0, 0.0);
+    else if (i >= 5) color = vec3(1.0, n, 0.0);
+
+    return color;
+}
+
+void main()
+{
+    vec4 pw = vec4(position, 1.0);
+    vec4 pc = view_matrix * pw;
+    gl_Position = projection_matrix * pc;
+    vec3 c = vec3(1.0, 1.0, 1.0);
+    if (color_mode == -1)
+    {
+        c = getRainbowColor(value);
+    }
+    else if(color_mode == -2)
+    {
+        c.z = float(value & uint(0x000000FF))/255.;
+        c.y = float((value & uint(0x0000FF00)) >> 8)/255.;
+        c.x = float((value & uint(0x00FF0000)) >> 16)/255.;
+    }
+    else if(color_mode == -3)
+    {
+        uint intensity = value >> 24;
+        c = getRainbowColor(intensity);
+    }
+    else
+    {
+        c.z = float( uint(color_mode) & uint(0x000000FF))/255.;
+        c.y = float((uint(color_mode) & uint(0x0000FF00)) >> 8)/255.;
+        c.x = float((uint(color_mode) & uint(0x00FF0000)) >> 16)/255.;
+    }
+    color = vec4(c, alpha);
+}
+"""
+
+fragment_shader = """
+#version 330 core
+
+in vec4 color;
+
+out vec4 finalColor;
+
+void main()
+{
+    finalColor = color;
+}
+"""
+
+
+def set_uniform_mat4(shader, content, name):
+    content = content.T
+    glUniformMatrix4fv(
+        glGetUniformLocation(shader, name),
+        1,
+        GL_FALSE,
+        content.astype(np.float32)
+    )
+
+
+# draw points with color (x, y, z, color)
+class CloudItem(gl.GLGraphicsItem.GLGraphicsItem):
+    def __init__(self, size, alpha, color_mode='I'):
+        super().__init__()
+        self.valid_buff_top = 0
+        self.add_buff_loc = 0
+        self.alpha = alpha
+        self.size = size
+        self.mutex = threading.Lock()
+        self.data_type = [('xyz', '<f4', (3,)), ('color', '<u4')]
+        self.color_mode = color_mode
+        self.setColorMode(color_mode)
+        self.CAPACITY = 10000000  # 10MB * 3 (x,y,z, color) * 4
+        self.vmax = 255
+        self.buff = np.empty((0), self.data_type)
+        self.wait_add_data = None
+        self.need_update_setting = True
+
+    def addSetting(self, layout):
+        label1 = QLabel("Set Size:")
+        layout.addWidget(label1)
+        box1 = QSpinBox()
+        box1.setSingleStep(1)
+        layout.addWidget(box1)
+        box1.setValue(self.size)
+        box1.valueChanged.connect(self.setSize)
+        box1.setRange(0, 100)
+
+        label2 = QLabel("Set Alpha:")
+        layout.addWidget(label2)
+        box2 = QDoubleSpinBox()
+        layout.addWidget(box2)
+        box2.setSingleStep(0.01)
+        box2.setValue(self.alpha)
+        box2.valueChanged.connect(self.setAlpha)
+        box2.setRange(0, 1)
+
+        label3 = QLabel("Set ColorMode:")
+        label3.setToolTip(
+            "'I': intensity mode; 'IRGB': IRGB mode; 'RGB': rgb mode; '#xxxxxx'; matplotlib color, i.e. #FF4500;")
+        layout.addWidget(label3)
+        box3 = QLineEdit()
+        box3.setToolTip(
+            "'I': intensity mode; 'IRGB': IRGB mode; 'RGB': rgb mode; '#xxxxxx'; matplotlib color, i.e. #FF4500;")
+
+        box3.setText(str(self.color_mode))
+        box3.textChanged.connect(self.setColorMode)
+        layout.addWidget(box3)
+
+    def setAlpha(self, alpha):
+        self.alpha = alpha
+        self.need_update_setting = True
+
+    def setVmax(self, vmax):
+        self.vmax = vmax
+        self.need_update_setting = True
+
+    def setColorMode(self, color_mode):
+        """
+        intensity mode: -1;
+        rgb mode: -2;
+        matplotlib color: i.e. '#FF4500';
+        """
+        if (type(color_mode) == str):
+            if color_mode.startswith("#"):
+                try:
+                    self.color_mode_int = int(color_mode[1:], 16)
+                except ValueError:
+                    return
+            elif color_mode == 'RGB':
+                self.color_mode_int = -2
+            elif color_mode == 'IRGB':
+                self.color_mode_int = -3
+            elif color_mode == 'I':
+                self.color_mode_int = -1
+        else:
+            return
+        self.color_mode = color_mode
+        self.need_update_setting = True
+
+    def setSize(self, size):
+        self.size = size
+
+    def clear(self):
+        data = np.empty((0), self.data_type)
+        self.setData(data)
+
+    def setData(self, data, append=False):
+        if data.dtype is np.dtype('float32') or data.dtype is np.dtype('float64'):
+            xyz = data[:, :3]
+            if (data.shape[1] == 4):
+                color = data[:, 3].view(np.uint32)
+            else:
+                color = np.zeros(data.shape[0], dtype=np.uint32)
+            data = np.rec.fromarrays(
+                [xyz, color],
+                dtype=self.data_type)
+        self.mutex.acquire()
+        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 updateSetting(self):
+        if (self.need_update_setting is False):
+            return
+        glUseProgram(self.program)
+        glUniform1i(glGetUniformLocation(
+            self.program, "color_mode"), self.color_mode_int)
+        glUniform1f(glGetUniformLocation(self.program, "vmax"), self.vmax)
+        glUniform1f(glGetUniformLocation(self.program, "alpha"), self.alpha)
+        glUseProgram(0)
+        self.need_update_setting = False
+
+    def updateRenderBuffer(self):
+        # is not new data dont update buff
+        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]:
+            # if need to update buff capacity, create new cpu buff and new vbo
+            buff_capacity = self.buff.shape[0]
+            while (new_buff_top > buff_capacity):
+                buff_capacity += self.CAPACITY
+            print("Update capacity to %d" % buff_capacity)
+            new_buff = np.empty((buff_capacity), self.data_type)
+            new_buff[:self.add_buff_loc] = self.buff[:self.add_buff_loc]
+            new_buff[self.add_buff_loc:new_buff_top] = self.wait_add_data
+            self.buff = new_buff
+            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 * 16,
+                            self.wait_add_data.shape[0] * 16, self.wait_add_data)
+        self.valid_buff_top = new_buff_top
+        self.wait_add_data = None
+        self.mutex.release()
+
+    def initializeGL(self):
+        self.program = shaders.compileProgram(
+            shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
+            shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER),
+        )
+        # Bind attribute locations
+        # set constant parameter for cloud shader
+        self.setAlpha(self.alpha)
+        self.setColorMode(self.color_mode)
+        self.setVmax(self.vmax)
+        self.vbo = glGenBuffers(1)
+
+    def paint(self):
+        self.setupGLState()
+        self.updateRenderBuffer()
+        self.updateSetting()
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        glUseProgram(self.program)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 16, ctypes.c_void_p(0))
+        glVertexAttribPointer(
+            1, 1, GL_FLOAT, GL_UNSIGNED_INT, 16, ctypes.c_void_p(12))
+        glEnableVertexAttribArray(0)
+        glEnableVertexAttribArray(1)
+
+        view_matrix = np.array(
+            self._GLGraphicsItem__view.viewMatrix().data(), np.float32).reshape([4, 4]).T
+        set_uniform_mat4(self.program, view_matrix, 'view_matrix')
+        project_matrix = np.array(self._GLGraphicsItem__view.projectionMatrix(
+        ).data(), np.float32).reshape([4, 4]).T
+        set_uniform_mat4(self.program, project_matrix, 'projection_matrix')
+
+        glPointSize(self.size)
+        glDrawArrays(GL_POINTS, 0, self.valid_buff_top)
+
+        # unbind VBO
+        glDisableVertexAttribArray(0)
+        glDisableVertexAttribArray(1)
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+        glUseProgram(0)