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

q3dviewer/custom_items/cloud_item.py

@@ -0,0 +1,314 @@
+"""
+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 threading
+import os
+from PySide6.QtWidgets import QLabel, QLineEdit, QDoubleSpinBox, \
+    QComboBox, QCheckBox
+from OpenGL.GL import shaders
+from q3dviewer.utils import *
+from q3dviewer.utils.range_slider import RangeSlider
+from PySide6.QtCore import QRegularExpression
+from PySide6.QtGui import QRegularExpressionValidator
+
+
+# draw points with color (x, y, z, color)
+class CloudItem(BaseItem):
+    def __init__(self, size, alpha, color_mode='I', color='#ffffff', point_type='PIXEL'):
+        super().__init__()
+        self.STRIDE = 16  # stride of cloud array
+        self.valid_buff_top = 0
+        self.add_buff_loc = 0
+        self.alpha = alpha
+        self.size = size
+        self.point_type = point_type
+        self.mutex = threading.Lock()
+        self.data_type = [('xyz', '<f4', (3,)), ('irgb', '<u4')]
+        self.flat_rgb = int(color[1:], 16)
+        self.mode_table = {'FLAT': 0,  'I': 1,  'RGB': 2}
+        self.point_type_table = {'PIXEL': 0, 'SQUARE': 1, 'SPHERE': 2}
+        self.color_mode = self.mode_table[color_mode]
+        self.CAPACITY = 10000000  # 10MB * 3 (x,y,z, color) * 4
+        self.vmin = 0
+        self.vmax = 255
+        self.buff = np.empty((0), self.data_type)
+        self.wait_add_data = None
+        self.need_update_setting = True
+        self.max_cloud_size = 300000000
+        # Enable depth test when full opaque
+        self.depth_test_enabled = (alpha == 1)
+        self.path = os.path.dirname(__file__)
+
+    def add_setting(self, layout):
+        label_ptype = QLabel("Set point display type:")
+        layout.addWidget(label_ptype)
+        combo_ptype = QComboBox()
+        combo_ptype.addItem("pixels")
+        combo_ptype.addItem("flat squares")
+        combo_ptype.addItem("spheres")
+        combo_ptype.setCurrentIndex(self.point_type_table[self.point_type])
+        combo_ptype.currentIndexChanged.connect(self._on_point_type_selection)
+        layout.addWidget(combo_ptype)
+        self.label_size = QLabel("Set size: (pixel)")
+        layout.addWidget(self.label_size)
+        self.box_size = QDoubleSpinBox()
+        self.box_size.setSingleStep(1)
+        self.box_size.setDecimals(0)
+        layout.addWidget(self.box_size)
+        self.box_size.setValue(self.size)
+        self.box_size.valueChanged.connect(self.set_size)
+        self.box_size.setRange(0, 100)
+
+        label_alpha = QLabel("Set Alpha:")
+        layout.addWidget(label_alpha)
+        box_alpha = QDoubleSpinBox()
+        layout.addWidget(box_alpha)
+        box_alpha.setSingleStep(0.01)
+        box_alpha.setValue(self.alpha)
+        box_alpha.valueChanged.connect(self.set_alpha)
+        box_alpha.setRange(0, 1)
+
+        label_color = QLabel("Set ColorMode:")
+        layout.addWidget(label_color)
+        self.combo_color = QComboBox()
+        self.combo_color.addItem("flat color")
+        self.combo_color.addItem("intensity")
+        self.combo_color.addItem("RGB")
+        self.combo_color.setCurrentIndex(self.color_mode)
+        self.combo_color.currentIndexChanged.connect(self._on_color_mode)
+        layout.addWidget(self.combo_color)
+
+        self.edit_rgb = QLineEdit()
+        self.edit_rgb.setToolTip("Hex number, i.e. #FF4500")
+        self.edit_rgb.setText(f"#{self.flat_rgb:06x}")
+        self.edit_rgb.textChanged.connect(self._on_color)
+        regex = QRegularExpression(r"^#[0-9A-Fa-f]{6}$")
+        validator = QRegularExpressionValidator(regex)
+        self.edit_rgb.setValidator(validator)
+        layout.addWidget(self.edit_rgb)
+
+        self.slider_v = RangeSlider()
+        self.slider_v.setRange(0, 255)
+        self.slider_v.rangeChanged.connect(self._on_range)
+
+        layout.addWidget(self.slider_v)
+        self.combo_color.setCurrentIndex(self.color_mode)
+
+        # Add a checkbox for enabling/disabling depth test
+        self.checkbox_depth_test = QCheckBox(
+            "Show front points first (Depth Test)")
+        self.checkbox_depth_test.setChecked(self.depth_test_enabled)
+        self.checkbox_depth_test.stateChanged.connect(self.set_depthtest)
+        layout.addWidget(self.checkbox_depth_test)
+
+    def _on_range(self, lower, upper):
+        self.vmin = lower
+        self.vmax = upper
+        self.need_update_setting = True
+
+    def _on_color_mode(self, index):
+        self.color_mode = index
+        self.edit_rgb.hide()
+        self.slider_v.hide()
+        if (index == self.mode_table['FLAT']):  # flat color
+            self.edit_rgb.show()
+        elif (index == self.mode_table['I']):  # flat color
+            self.slider_v.show()
+        self.need_update_setting = True
+
+    def set_color_mode(self, color_mode):
+        if color_mode in {'FLAT', 'RGB', 'I'}:
+            self.combo_color.setCurrentIndex(self.mode_table[color_mode])
+        else:
+            print(f"Invalid color mode: {color_mode}")
+
+    def _on_point_type_selection(self, index):
+        self.point_type = list(self.point_type_table.keys())[index]
+        if self.point_type == 'PIXEL':
+            self.label_size.setText("Set size: (pixel)")
+            self.box_size.setDecimals(0)
+            self.box_size.setSingleStep(1)
+            self.box_size.setValue(1)
+            self.size = 1
+        else:
+            self.label_size.setText("Set size: (meter)")
+            self.box_size.setDecimals(2)
+            self.box_size.setSingleStep(0.01)
+            self.box_size.setValue(0.01)
+            self.size = 0.01
+        self.need_update_setting = True
+
+    def set_alpha(self, alpha):
+        self.alpha = alpha
+        self.need_update_setting = True
+
+    def set_flat_rgb(self, color):
+        try:
+            self.edit_rgb.setText(color)
+        except ValueError:
+            pass
+
+    def _on_color(self, color):
+        try:
+            flat_rgb = int(color[1:], 16)
+            self.flat_rgb = flat_rgb
+            self.need_update_setting = True
+        except ValueError:
+            pass
+
+    def set_size(self, size):
+        self.size = size
+        self.need_update_setting = True
+
+    def set_depthtest(self, state):
+        self.depth_test_enabled = state
+
+    def clear(self):
+        data = np.empty((0), self.data_type)
+        self.set_data(data)
+
+    def set_data(self, data, append=False):
+        if not isinstance(data, np.ndarray):
+            raise ValueError("Input data must be a numpy array.")
+
+        if data.dtype in {np.dtype('float32'), np.dtype('float64')}:
+            if data.size == 0:
+                data = np.empty((0), self.data_type)
+            elif data.ndim == 2 and data.shape[1] >= 3:
+                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[:data.shape[0]]], dtype=self.data_type)
+
+        with self.mutex:
+            if append:
+                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
+            else:
+                self.wait_add_data = data
+                self.add_buff_loc = 0
+
+            while self.add_buff_loc + self.wait_add_data.shape[0] > self.max_cloud_size:
+                # Randomly select half of the points
+                print(
+                    "Warning: Buffer size exceeds the maximum cloud size. Randomly selecting half of the points.")
+                indices = np.random.choice(
+                    self.add_buff_loc, self.add_buff_loc // 2, replace=False)
+                self.buff[:self.add_buff_loc // 2] = self.buff[indices]
+                self.add_buff_loc //= 2
+                indices = np.random.choice(
+                    self.wait_add_data.shape[0], self.wait_add_data.shape[0] // 2, replace=False)
+                self.wait_add_data = self.wait_add_data[indices]
+
+    def update_setting(self):
+        if (self.need_update_setting is False):
+            return
+        glUseProgram(self.program)
+        set_uniform(self.program, int(self.flat_rgb), 'flat_rgb')
+        set_uniform(self.program, int(self.color_mode), 'color_mode')
+        set_uniform(self.program, float(self.vmax), 'vmax')
+        set_uniform(self.program, float(self.vmin), 'vmin')
+        set_uniform(self.program, float(self.alpha), 'alpha')
+        set_uniform(self.program, float(self.size), 'point_size')
+        set_uniform(self.program, int(self.point_type_table[self.point_type]), 'point_type')
+        glUseProgram(0)
+        self.need_update_setting = False
+
+    def update_render_buffer(self):
+        # Ensure there is data waiting to be added to the buffer
+        if (self.wait_add_data is None):
+            return
+        # Acquire lock to update the buffer safely
+        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("[Cloud Item] 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 * self.STRIDE,
+                            self.wait_add_data.shape[0] * self.STRIDE,
+                            self.wait_add_data)
+        self.valid_buff_top = new_buff_top
+        self.wait_add_data = None
+        self.mutex.release()
+
+    def initialize_gl(self):
+        vertex_shader = open(self.path + '/../shaders/cloud_vert.glsl', 'r').read()
+        fragment_shader = open(self.path + '/../shaders/cloud_frag.glsl', 'r').read()
+        self.program = shaders.compileProgram(
+            shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
+            shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER),
+        )
+        self.max_cloud_size = glGetIntegerv(
+            GL_MAX_SHADER_STORAGE_BLOCK_SIZE) // self.STRIDE
+        # Bind attribute locations
+        self.vbo = glGenBuffers(1)
+
+    def paint(self):
+        self.update_render_buffer()
+        self.update_setting()
+        glEnable(GL_BLEND)
+        glEnable(GL_PROGRAM_POINT_SIZE)
+        glEnable(GL_POINT_SPRITE)
+        if self.depth_test_enabled:
+            glEnable(GL_DEPTH_TEST)
+        else:
+            glDisable(GL_DEPTH_TEST)
+
+        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,
+                              self.STRIDE, ctypes.c_void_p(0))
+        glVertexAttribPointer(
+            1, 1, GL_FLOAT, GL_UNSIGNED_INT, self.STRIDE, ctypes.c_void_p(12))
+        glEnableVertexAttribArray(0)
+        glEnableVertexAttribArray(1)
+
+        view_matrix = self.glwidget().get_view_matrix()
+        set_uniform(self.program, view_matrix, 'view_matrix')
+        project_matrix = self.glwidget().get_projection_matrix()
+        set_uniform(self.program, project_matrix, 'projection_matrix')
+        width = self.glwidget().current_width()
+        focal = project_matrix[0, 0] * width / 2
+        set_uniform(self.program, float(focal), 'focal')
+
+        glDrawArrays(GL_POINTS, 0, self.valid_buff_top)
+
+        # unbind VBO
+        glDisableVertexAttribArray(0)
+        glDisableVertexAttribArray(1)
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+        glUseProgram(0)
+        glDisable(GL_POINT_SPRITE)
+        glDisable(GL_PROGRAM_POINT_SIZE)
+        glDisable(GL_BLEND)
+        if self.depth_test_enabled:
+            glDisable(GL_DEPTH_TEST)  # Disable depth testing if it was enabled

q3dviewer/custom_items/frame_item.py

@@ -0,0 +1,194 @@
+"""
+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 q3dviewer.utils import *
+
+
+# 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;
+uniform mat4 model_matrix;
+
+void main()
+{
+    gl_Position = project_matrix * view_matrix * model_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);
+}
+"""
+
+
+class FrameItem(BaseItem):
+    def __init__(self, T=np.eye(4), size=(1, 0.8), width=3, img=None):
+        BaseItem.__init__(self)
+        self.w, self.h = size
+        self.width = width
+        self.T = T
+        self.img = img
+        self.texture = None
+        self.need_updating = False
+
+    def initialize_gl(self):
+        # Rectangle vertices and texture coordinates
+        hw = self.w / 2
+        hh = self.h / 2
+        self.vertices = np.array([
+            # positions          # texture coords
+            [-hw, -hh,  0.0,  0.0, 0.0],  # bottom-left
+            [hw, -hh,  0.0,  1.0, 0.0],  # bottom-right
+            [hw,  hh,  0.0,  1.0, 1.0],  # top-right
+            [-hw,  hh,  0.0,  0.0, 1.0],   # top-left
+            [0,  0, -hh * 0.66, 0.0, 0.0],   # top-left
+        ], dtype=np.float32)
+
+        self.indices = np.array([
+            0, 1, 2,  # first triangle
+            2, 3, 0   # second triangle
+        ], dtype=np.uint32)
+
+        self.vao = glGenVertexArrays(1)
+        self.vbo = glGenBuffers(1)
+        self.ebo = glGenBuffers(1)
+
+        glBindVertexArray(self.vao)
+
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        glBufferData(GL_ARRAY_BUFFER, self.vertices.itemsize *
+                     5 * 4, self.vertices, GL_STATIC_DRAW)
+
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.ebo)
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER,
+                     self.indices.nbytes, self.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 = self.glwidget().get_projection_matrix()
+        # 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(self.program, np.eye(4), 'model_matrix')
+        set_uniform(self.program, project_matrix, 'project_matrix')
+        glUseProgram(0)
+        self.texture = glGenTextures(1)
+        self.set_data(img=self.img)
+        
+        # Define line vertices
+        self.line_vertices = np.array([
+            self.vertices[0, :3], self.vertices[1, :3],
+            self.vertices[1, :3], self.vertices[2, :3],
+            self.vertices[2, :3], self.vertices[3, :3],
+            self.vertices[3, :3], self.vertices[0, :3],
+            self.vertices[4, :3], self.vertices[0, :3],
+            self.vertices[4, :3], self.vertices[1, :3],
+            self.vertices[4, :3], self.vertices[2, :3],
+            self.vertices[4, :3], self.vertices[3, :3]
+        ], dtype=np.float32)
+
+        self.line_vbo = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.line_vbo)
+        glBufferData(GL_ARRAY_BUFFER, self.line_vertices.nbytes, self.line_vertices, GL_STATIC_DRAW)
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        glBindVertexArray(0)
+
+    def set_transform(self, T):
+        self.T = T
+
+    def set_data(self, img=None, transform=None):
+        if transform is not None:
+            self.T = transform
+        self.img = img
+        self.need_updating = True
+
+    def update_img_buffer(self):
+        if self.img is not None and self.need_updating:
+            self.texture = glGenTextures(1)
+            glBindTexture(GL_TEXTURE_2D, self.texture)
+            # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
+            # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
+            # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+            # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+            if self.img.ndim == 2:
+                # Convert grayscale to RGBA
+                self.img = np.stack((self.img,) * 3 + (np.ones_like(self.img) * 255,), axis=-1)
+            elif self.img.shape[2] == 3:
+                # Add an alpha channel
+                alpha_channel = np.ones((self.img.shape[0], self.img.shape[1], 1), dtype=np.uint8) * 255
+                self.img = np.concatenate((self.img, alpha_channel), axis=2)
+            
+            img = np.ascontiguousarray(self.img, dtype=np.uint8)
+
+            # Load image
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img.shape[1],
+                         img.shape[0], 0, GL_RGBA, GL_UNSIGNED_BYTE, img)
+            glGenerateMipmap(GL_TEXTURE_2D)
+            glBindTexture(GL_TEXTURE_2D, 0)
+            self.need_updating = False
+
+    def paint(self):
+        self.view_matrix = self.glwidget().get_view_matrix()
+        project_matrix = self.glwidget().get_projection_matrix()
+        self.update_img_buffer()
+
+        glEnable(GL_DEPTH_TEST)
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+
+        glUseProgram(self.program)
+        set_uniform(self.program, self.view_matrix, 'view_matrix')
+        set_uniform(self.program, project_matrix, 'project_matrix')
+        set_uniform(self.program, self.T, 'model_matrix')
+        glBindVertexArray(self.vao)
+        
+        if self.texture is not None:
+            glBindTexture(GL_TEXTURE_2D, self.texture)
+            glMultMatrixf(self.T.T)  # Apply the transformation matrix
+            glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, None)
+            glBindTexture(GL_TEXTURE_2D, 0)
+        
+        glBindVertexArray(0)
+        glUseProgram(0)
+
+        glLineWidth(self.width)
+        glColor4f(1, 1, 1, 1)  # Set the color before drawing the lines
+        glBindBuffer(GL_ARRAY_BUFFER, self.line_vbo)
+        glEnableClientState(GL_VERTEX_ARRAY)
+        glVertexPointer(3, GL_FLOAT, 0, None)
+        glDrawArrays(GL_LINES, 0, len(self.line_vertices))
+        glDisableClientState(GL_VERTEX_ARRAY)
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+
+        glDisable(GL_DEPTH_TEST)
+        glDisable(GL_BLEND)