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

q3dviewer/custom_items/gaussian_item.py

@@ -0,0 +1,254 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+import numpy as np
+from q3dviewer.base_item import BaseItem
+from OpenGL.GL import *
+import numpy as np
+import os
+from PySide6.QtWidgets import QComboBox, QLabel
+from OpenGL.GL import shaders
+from q3dviewer.utils import *
+
+
+def div_round_up(x, y):
+    return int((x + y - 1) / y)
+
+
+class GaussianItem(BaseItem):
+    def __init__(self, **kwds):
+        super().__init__()
+        self.need_updateGS = False
+        self.sh_dim = 0
+        self.gs_data = np.empty([0])
+        self.prev_Rz = np.array([np.inf, np.inf, np.inf])
+        self.path = os.path.dirname(__file__)
+        try:
+            import torch
+            if not torch.cuda.is_available():
+                raise ImportError
+            self.cuda_pw = None
+            self.sort = self.torch_sort
+        except ImportError:
+            self.sort = self.openg_sort
+
+    def add_setting(self, layout):
+        label1 = QLabel("set render mode:")
+        layout.addWidget(label1)
+        combo = QComboBox()
+        combo.addItem("render normal guassian")
+        combo.addItem("render ball")
+        combo.addItem("render inverse guassian")
+        combo.currentIndexChanged.connect(self.onComboboxSelection)
+        layout.addWidget(combo)
+
+    def onComboboxSelection(self, index):
+        glUseProgram(self.program)
+        set_uniform(self.program, index, 'render_mod')
+        glUseProgram(0)
+
+    def initialize_gl(self):
+        fragment_shader = open(
+            self.path + '/../shaders/gau_frag.glsl', 'r').read()
+        vertex_shader = open(
+            self.path + '/../shaders/gau_vert.glsl', 'r').read()
+        sort_shader = open(
+            self.path + '/../shaders/sort_by_key.glsl', 'r').read()
+        prep_shader = open(self.path + '/../shaders/gau_prep.glsl', 'r').read()
+
+        self.sort_program = shaders.compileProgram(
+            shaders.compileShader(sort_shader, GL_COMPUTE_SHADER))
+
+        self.prep_program = shaders.compileProgram(
+            shaders.compileShader(prep_shader, GL_COMPUTE_SHADER))
+
+        self.program = shaders.compileProgram(
+            shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
+            shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER),
+        )
+        self.vao = glGenVertexArrays(1)
+
+        # trade a gaussian as a square (4 2d points)
+        square_vert = np.array([-1, 1, 1, 1, 1, -1, -1, -1], dtype=np.float32)
+        indices = np.array([0, 1, 2, 0, 2, 3], dtype=np.uint32)
+
+        # set the vertices for square
+        vbo = glGenBuffers(1)
+        glBindVertexArray(self.vao)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo)
+        glBufferData(GL_ARRAY_BUFFER, square_vert.nbytes,
+                     square_vert, GL_STATIC_DRAW)
+        pos = glGetAttribLocation(self.program, 'vert')
+        glVertexAttribPointer(pos, 2, GL_FLOAT, False, 0, None)
+        glEnableVertexAttribArray(pos)
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        # the vert's indices for drawing square
+        self.ebo = glGenBuffers(1)
+        glBindVertexArray(self.vao)
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.ebo)
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
+                     indices.nbytes, indices, GL_STATIC_DRAW)
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
+        glBindVertexArray(0)
+
+        # add SSBO for gaussian data
+        self.ssbo_gs = glGenBuffers(1)
+        self.ssbo_gi = glGenBuffers(1)
+        self.ssbo_dp = glGenBuffers(1)
+        self.ssbo_pp = glGenBuffers(1)
+
+        width = self.glwidget().current_width()
+        height = self.glwidget().current_height()
+
+        # set constant parameter for gaussian shader
+        project_matrix = self.glwidget().get_projection_matrix()
+        focal_x = project_matrix[0, 0] * width / 2
+        focal_y = project_matrix[1, 1] * height / 2
+        glUseProgram(self.prep_program)
+        set_uniform(self.prep_program,
+                    project_matrix, 'projection_matrix')
+        set_uniform(self.prep_program, np.array([focal_x, focal_y]), 'focal')
+        glUseProgram(0)
+
+        glUseProgram(self.program)
+        set_uniform(self.program, np.array([width, height]), 'win_size')
+        set_uniform(self.program, 0, 'render_mod')
+        glUseProgram(0)
+
+        # opengl settings
+        glDisable(GL_CULL_FACE)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+
+    def updateGS(self):
+        if (self.need_updateGS):
+            # compute sorting size
+            self.num_sort = int(2**np.ceil(np.log2(self.gs_data.shape[0])))
+
+            # set input gaussian data
+            glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_gs)
+            glBufferData(GL_SHADER_STORAGE_BUFFER, self.gs_data.nbytes,
+                         self.gs_data.reshape(-1), GL_STATIC_DRAW)
+            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, self.ssbo_gs)
+            glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
+
+            # set depth for sorting
+            glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_dp)
+            glBufferData(GL_SHADER_STORAGE_BUFFER,
+                         self.num_sort * 4, None, GL_STATIC_DRAW)
+            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, self.ssbo_dp)
+            glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
+
+            # set index for sorting (the index need be initialized)
+            gi = np.arange(self.num_sort, dtype=np.uint32)
+            glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_gi)
+            glBufferData(GL_SHADER_STORAGE_BUFFER,
+                         self.num_sort * 4, gi, GL_STATIC_DRAW)
+            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, self.ssbo_gi)
+            glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
+
+            # set preprocess buffer
+            # the dim of preprocess data is 12 u(3),
+            # covinv(3), color(3), area(2), alpha(1)
+            glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_pp)
+            glBufferData(GL_SHADER_STORAGE_BUFFER,
+                         self.gs_data.shape[0] * 4 * 12,
+                         None, GL_STATIC_DRAW)
+            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, self.ssbo_pp)
+            glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
+
+            glUseProgram(self.prep_program)
+            set_uniform(self.prep_program, self.sh_dim, 'sh_dim')
+            set_uniform(self.prep_program,
+                        self.gs_data.shape[0], 'gs_num')
+            glUseProgram(0)
+            self.need_updateGS = False
+
+    def paint(self):
+        # get current view matrix
+        self.view_matrix = self.glwidget().get_view_matrix()
+
+        # if gaussian data is update, renew vao, ssbo, etc...
+        self.updateGS()
+
+        if (self.gs_data.shape[0] == 0):
+            return
+
+        # preprocess and sort gaussian by compute shader.
+        self.preprocessGS()
+        self.try_sort()
+        glEnable(GL_BLEND)
+        # draw by vert shader
+        glUseProgram(self.program)
+        # bind vao and ebo
+        glBindVertexArray(self.vao)
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.ebo)
+        # draw instances
+        glDrawElementsInstanced(
+            GL_TRIANGLES, 6, GL_UNSIGNED_INT, None, self.gs_data.shape[0])
+        # upbind vao and ebo
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
+        glBindVertexArray(0)
+        glUseProgram(0)
+        glDisable(GL_BLEND)
+
+    def try_sort(self):
+        # don't sort if the depths are not change.
+        Rz = self.view_matrix[2, :3]
+        if (np.linalg.norm(self.prev_Rz - Rz) > 0.1):
+            # import torch
+            # torch.cuda.synchronize()
+            # start = time.time()
+            self.sort()
+            self.prev_Rz = Rz
+            # torch.cuda.synchronize()
+            # end = time.time()
+            # time_diff = end - start
+            # print(time_diff)
+
+    def openg_sort(self):
+        glUseProgram(self.sort_program)
+        # can we move this loop to gpu?
+        # level = level*2
+        for level in 2**np.arange(1, int(np.ceil(np.log2(self.num_sort))+1)):
+            # stage =stage / 2
+            for stage in level/2**np.arange(1, np.log2(level)+1):
+                set_uniform(self.sort_program, int(level), 'level')
+                set_uniform(self.sort_program, int(stage), 'stage')
+                glDispatchCompute(div_round_up(self.num_sort//2, 256), 1, 1)
+                glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT)
+        # glFinish()
+        glUseProgram(0)
+
+    def torch_sort(self):
+        import torch
+        if self.cuda_pw is None:
+            self.cuda_pw = torch.tensor(self.gs_data[:, :3]).cuda()
+        Rz = torch.tensor(self.view_matrix[2, :3].astype(np.float32)).cuda()
+        depth = Rz @ self.cuda_pw.T
+        index = torch.argsort(depth).type(torch.int32).cpu().numpy()
+        glBindBuffer(GL_SHADER_STORAGE_BUFFER, self.ssbo_gi)
+        glBufferData(GL_SHADER_STORAGE_BUFFER,
+                     index.nbytes, index, GL_STATIC_DRAW)
+        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, self.ssbo_gi)
+        glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
+        return index
+
+    def preprocessGS(self):
+        glUseProgram(self.prep_program)
+        set_uniform(self.prep_program, self.view_matrix, 'view_matrix')
+        glDispatchCompute(div_round_up(self.gs_data.shape[0], 256), 1, 1)
+        glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT)
+        glUseProgram(0)
+
+    def set_data(self, **kwds):
+        if 'gs_data' in kwds:
+            self.need_updateGS = False
+            gs_data = kwds.pop('gs_data')
+            self.gs_data = np.ascontiguousarray(gs_data, dtype=np.float32)
+            self.sh_dim = self.gs_data.shape[-1] - (3 + 4 + 3 + 1)
+            self.prev_Rz = np.array([np.inf, np.inf, np.inf])
+            self.cuda_pw = None
+            self.need_updateGS = True

q3dviewer/custom_items/grid_item.py

@@ -0,0 +1,88 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+from q3dviewer.base_item import BaseItem
+from OpenGL.GL import *
+from PySide6.QtWidgets import QLabel, QDoubleSpinBox, QLineEdit
+from PySide6.QtCore import QRegularExpression
+from PySide6.QtGui import QRegularExpressionValidator
+import numpy as np
+
+
+class GridItem(BaseItem):
+    def __init__(self, size, spacing, color=np.array([255, 255, 255, 76.5]), offset=np.array([0, 0, 0])):
+        super().__init__()
+        self.size = size
+        self.spacing = spacing
+        self.color = color
+        self.offset = offset
+
+    def add_setting(self, layout):
+        label_size = QLabel("Set size:")
+        layout.addWidget(label_size)
+        spinbox_size = QDoubleSpinBox()
+        spinbox_size.setSingleStep(1.0)
+        layout.addWidget(spinbox_size)
+        spinbox_size.setValue(self.size)
+        spinbox_size.valueChanged.connect(self.set_size)
+        spinbox_size.setRange(0, 100000)
+
+        label_spacing = QLabel("Set spacing:")
+        layout.addWidget(label_spacing)
+        spinbox_spacing = QDoubleSpinBox()
+        layout.addWidget(spinbox_spacing)
+        spinbox_spacing.setSingleStep(0.1)
+        spinbox_spacing.setValue(self.spacing)
+        spinbox_spacing.valueChanged.connect(self._on_spacing)
+        spinbox_spacing.setRange(0, 1000)
+
+        label_offset = QLabel("Set offset (x;y;z):")
+        layout.addWidget(label_offset)
+        self.edit_offset = QLineEdit()
+        regex = QRegularExpression(r"^-?\d+(\.\d+)?;-?\d+(\.\d+)?;-?\d+(\.\d+)?$")
+        validator = QRegularExpressionValidator(regex)
+        self.edit_offset.setValidator(validator)
+        self.edit_offset.setText(f"{self.offset[0]};{self.offset[1]};{self.offset[2]}")
+        self.edit_offset.textChanged.connect(self._on_offset)
+        layout.addWidget(self.edit_offset)
+
+    def set_size(self, size):
+        self.size = size
+
+    def _on_spacing(self, spacing):
+        if spacing > 0:
+            self.spacing = spacing
+
+    def _on_offset(self, text):
+        try:
+            values = list(map(float, text.split(';')))
+            if len(values) == 3:
+                self.offset = np.array(values)
+            else:
+                raise ValueError("Offset must have 3 values separated by ';'")
+        except ValueError:
+            pass
+
+    def set_offset(self, offset):
+        if isinstance(offset, np.ndarray) and offset.shape == (3,):
+            self.offset = offset
+            self.edit_offset.setText(f"{self.offset[0]};{self.offset[1]};{self.offset[2]}")
+        else:
+            raise ValueError("Offset must be a numpy array with shape (3,)")
+
+    def paint(self):
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        glColor4f(self.color[0] / 255.0, self.color[1] / 255.0, self.color[2] / 255.0, self.color[3] / 255.0)
+        glBegin(GL_LINES)
+        for i in np.arange(-self.size, self.size + self.spacing, self.spacing):
+            glVertex3f(i + self.offset[0], -self.size + self.offset[1], self.offset[2])
+            glVertex3f(i + self.offset[0], self.size + self.offset[1], self.offset[2])
+            glVertex3f(-self.size + self.offset[0], i + self.offset[1], self.offset[2])
+            glVertex3f(self.size + self.offset[0], i + self.offset[1], self.offset[2])
+        glEnd()
+        glDisable(GL_BLEND)
+
+

q3dviewer/custom_items/image_item.py

@@ -0,0 +1,172 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+from q3dviewer.base_item import BaseItem
+from OpenGL.GL import *
+import numpy as np
+from OpenGL.GL import shaders
+from PIL import Image as PIL_Image
+from PySide6.QtWidgets import QLabel, QSpinBox, QCheckBox
+
+
+# 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);
+}
+"""
+
+
+class ImageItem(BaseItem):
+    def __init__(self, pos=np.array([0, 0]), size=np.array([1280/2, 720/2])):
+        BaseItem.__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 initialize_gl(self):
+        # Rectangle vertices and texture coordinates
+        width = self.glwidget().current_width()
+        height = self.glwidget().current_height()
+        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 set_data(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 add_setting(self, layout):
+        alpha_label = QLabel("Set Alpha:")
+        layout.addWidget(alpha_label)
+        spinbox_alpha = QSpinBox()
+        spinbox_alpha.setSingleStep(1)
+        spinbox_alpha.setRange(0, 255)
+        spinbox_alpha.setValue(self.alpha)
+        spinbox_alpha.valueChanged.connect(self.set_alpha)
+        layout.addWidget(spinbox_alpha)
+        
+        checkbox_show = QCheckBox("Show Image")
+        checkbox_show.setChecked(True)
+        checkbox_show.stateChanged.connect(self.set_visible)
+        layout.addWidget(checkbox_show)
+
+    def set_alpha(self, alpha):
+        self.alpha = alpha

q3dviewer/custom_items/line_item.py

@@ -0,0 +1,120 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+from q3dviewer.base_item import BaseItem
+from OpenGL.GL import *
+import numpy as np
+import threading
+from PySide6.QtWidgets import QLabel, QLineEdit, QDoubleSpinBox
+from PySide6.QtCore import QRegularExpression
+from PySide6.QtGui import QRegularExpressionValidator
+from q3dviewer.utils.maths import hex_to_rgba
+
+
+class LineItem(BaseItem):
+    def __init__(self, width=1, color='#00ff00', line_type='LINE_STRIP'):
+        super(LineItem, 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
+        self.rgb = hex_to_rgba(color)
+        self.line_type = GL_LINE_STRIP if line_type == 'LINE_STRIP' else GL_LINES
+
+    def add_setting(self, layout):
+        label_color = QLabel("Set trajectory color:")
+        layout.addWidget(label_color)
+        self.color_edit = QLineEdit()
+        self.color_edit.setToolTip("Hex number, i.e. #FF4500")
+        self.color_edit.setText(self.color)
+        self.color_edit.textChanged.connect(self._on_color)
+        regex = QRegularExpression(r"^#[0-9A-Fa-f]{6}$")
+        validator = QRegularExpressionValidator(regex)
+        self.color_edit.setValidator(validator)
+        layout.addWidget(self.color_edit)
+
+        label_width = QLabel("Set width:")
+        layout.addWidget(label_width)
+        spinbox_width = QDoubleSpinBox()
+        spinbox_width.setSingleStep(0.1)
+        layout.addWidget(spinbox_width)
+        spinbox_width.setValue(self.width)
+        spinbox_width.valueChanged.connect(self.set_width)
+        spinbox_width.setRange(0.1, 10.0)
+
+    def _on_color(self, color):
+        try:
+            self.rgb = hex_to_rgba(color)
+            self.color = color
+        except ValueError:
+            pass
+
+    def set_color(self, color):
+        self.color_edit.setText(color)
+
+    def set_width(self, width):
+        self.width = width
+
+    def set_data(self, data, append=False):
+        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 update_render_buffer(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 initialize_gl(self):
+        self.vbo = glGenBuffers(1)
+
+    def paint(self):
+        self.update_render_buffer()
+        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.rgb)
+
+        glDrawArrays(self.line_type, 0, self.valid_buff_top)
+        glDisableClientState(GL_VERTEX_ARRAY)
+
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+        glDisable(GL_BLEND)

q3dviewer/custom_items/text_item.py

@@ -0,0 +1,63 @@
+"""
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+"""
+
+from PySide6 import QtCore, QtGui
+from q3dviewer.base_item import BaseItem
+from OpenGL.GL import *
+from q3dviewer.utils.maths import hex_to_rgba
+
+
+class Text2DItem(BaseItem):
+    """Draws text over opengl 3D."""
+
+    def __init__(self, **kwds):
+        """All keyword arguments are passed to set_data()"""
+        BaseItem.__init__(self)
+        self.pos = (20, 50)
+        self.color = '#ffffff'
+        self.rgb = hex_to_rgba(self.color)
+        self.text = ''
+        self.font = QtGui.QFont('Helvetica', 16)
+        self.set_data(**kwds)
+
+    def set_data(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':
+                    self.set_color(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)
+
+    def set_color(self, color):
+        try:
+            self.rgb = hex_to_rgba(color)
+            self.color = color
+        except ValueError:
+            pass
+
+    def paint(self):
+        if len(self.text) < 1:
+            return
+
+        text_pos = QtCore.QPointF(*self.pos)
+        painter = QtGui.QPainter(self.glwidget())
+        painter.setPen(QtGui.QColor(*[int(c * 255) for c in self.rgb[:3]]))
+        painter.setFont(self.font)
+        painter.setRenderHints(QtGui.QPainter.RenderHint.Antialiasing |
+                               QtGui.QPainter.RenderHint.TextAntialiasing)
+        painter.drawText(text_pos, self.text)
+        painter.end()