q3dviewer 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl

q3dviewer/custom_items/mesh_item.py

@@ -10,148 +10,75 @@ import numpy as np
 from q3dviewer.base_item import BaseItem
 from OpenGL.GL import *
 from OpenGL.GL import shaders
-from q3dviewer.Qt.QtWidgets import QLabel, QCheckBox, QDoubleSpinBox, QSlider, QHBoxLayout, QLineEdit, QComboBox
-import matplotlib.colors as mcolors
+from q3dviewer.Qt.QtWidgets import QLabel, QCheckBox, QDoubleSpinBox, QSlider, QHBoxLayout, QLineEdit
+
 import os
 from q3dviewer.utils import set_uniform, text_to_rgba
+import time
 
 
 
 class MeshItem(BaseItem):
     """
-    An OpenGL mesh item for rendering triangulated 3D surfaces.
-
+    A OpenGL mesh item for rendering 3D triangular meshes.
     Attributes:
-        color (str or tuple): The flat color to use when `color_mode` is 'FLAT'. 
-            Accepts any valid matplotlib color (e.g., 'lightblue', 'red', '#FF4500', (1.0, 0.5, 0.0)).
-        wireframe (bool): If True, render the mesh in wireframe mode (edges only). 
-            If False, render filled triangles. Default is False.
-        enable_lighting (bool): Whether to enable Phong lighting for the mesh. 
-            If True, the mesh will be shaded based on light direction and material properties.
-            If False, the mesh will use flat shading with object colors only. Default is True.
-        color_mode (str): The coloring mode for mesh vertices.
-            - 'FLAT': Single flat color for all vertices (uses the `color` attribute).
-            - 'I': Color by intensity channel from per-vertex colors (rainbow gradient).
-            - 'RGB': Per-vertex RGB color from per-vertex color data.
-        alpha (float): The transparency of the mesh, in the range [0, 1], 
-            where 0 is fully transparent and 1 is fully opaque. Default is 1.0.
-        line_width (float): The width of lines when rendering in wireframe mode. 
-            Range is typically 0.5 to 5.0. Default is 1.0.
-        
-    Material Properties (Phong Lighting):
-        ambient_strength (float): Ambient light contribution [0.0-1.0]. Default is 0.1.
-        diffuse_strength (float): Diffuse light contribution [0.0-2.0]. Default is 1.2.
-        specular_strength (float): Specular highlight contribution [0.0-2.0]. Default is 0.1.
-        shininess (float): Specular shininess exponent [1-256]. Higher values = smaller highlights. Default is 32.0.
-        
-    Methods:
-        set_data(verts, faces, colors=None): Set mesh geometry and optional per-vertex colors.
-            - verts: np.ndarray of shape (N, 3) - vertex positions
-            - faces: np.ndarray of shape (M, 3) with uint32 indices - triangle indices
-            - colors: np.ndarray of shape (N,) with uint32 IRGB format (optional)
-                     uint32 format: I (bits 24-31), R (bits 16-23), G (bits 8-15), B (bits 0-7)
-                     
-    Example:
-        # Create a simple triangle mesh with per-vertex colors
-        verts = np.array([[0,0,0], [1,0,0], [0,1,0]], dtype=np.float32)
-        faces = np.array([[0,1,2]], dtype=np.uint32)
-        colors = np.array([
-            (255 << 24) | (255 << 16) | (0 << 8) | 0,  # Red, intensity=255
-            (200 << 24) | (0 << 16) | (255 << 8) | 0,  # Green, intensity=200
-            (150 << 24) | (0 << 16) | (0 << 8) | 255   # Blue, intensity=150
-        ], dtype=np.uint32)
-        
-        mesh = q3d.MeshItem(color='lightblue', color_mode='RGB', enable_lighting=True)
-        mesh.set_data(verts, faces, colors)
+        color (str or tuple): Accepts any valid matplotlib color (e.g., 'red', '#FF4500', (1.0, 0.5, 0.0)).
+        wireframe (bool): If True, renders the mesh in wireframe mode.
     """
-    def __init__(self, color='lightblue', wireframe=False, enable_lighting=True, color_mode='FLAT'):
+    def __init__(self, color='lightblue', wireframe=False):
         super(MeshItem, self).__init__()
+        self.wireframe = wireframe
         self.color = color
         self.flat_rgb = text_to_rgba(color, flat=True)
-        self.wireframe = wireframe
-        self.enable_lighting = enable_lighting
         
-        # Mesh data
-        self.triangles = None
-        self.normals = None
-        self.vertex_colors = None  # Per-vertex colors (uint32 IRGB format)
+        # Incremental buffer management
+        self.FACE_CAPACITY = 1000000    # Initial capacity for faces
+        
+        # Faces buffer: N x 13 numpy array
+        # Each row: [v0.x, v0.y, v0.z, v1.x, v1.y, v1.z, v2.x, v2.y, v2.z, v3.x, v3.y, v3.z, good]
+        self.faces = np.zeros((self.FACE_CAPACITY, 13), dtype=np.float32)
+        
+        # valid_f_top: pointer to end of valid faces
+        self.valid_f_top = 0
         
-        self.mode_table = {'FLAT': 0, 'I': 1, 'RGB': 2}
-        self.color_mode = self.mode_table[color_mode]
-        self.vmin = 0
-        self.vmax = 255
+        # key2index: mapping from face_key to face buffer index
+        self.key2index = {}  # {face_key: face_index}
         
         # OpenGL objects
         self.vao = None
-        self.vbo_vertices = None
-        self.vbo_normals = None
-        self.vbo_colors = None
+        self.vbo = None
         self.program = None
+        self._gpu_face_capacity = 0    # Track GPU buffer capacity
         
-        # Rendering parameters
+        # Fixed rendering parameters (not adjustable via UI)
+        self.enable_lighting = True
         self.line_width = 1.0
         self.light_pos = [1.0, 1.0, 1.0]
         self.light_color = [1.0, 1.0, 1.0]
-        
-        # Phong lighting material properties
         self.ambient_strength = 0.1
         self.diffuse_strength = 1.2
         self.specular_strength = 0.1
         self.shininess = 32.0
-        # Alpha (opacity)
         self.alpha = 1.0
         
-        # Buffer initialization flag
-        self.need_update_buffer = True
+        # Settings flag
         self.need_update_setting = True
         self.path = os.path.dirname(__file__)
     
         
     def add_setting(self, layout):
         """Add UI controls for mesh visualization"""
-        # Wireframe toggle
+        # Only keep wireframe toggle - all other parameters are fixed
         self.wireframe_box = QCheckBox("Wireframe Mode")
         self.wireframe_box.setChecked(self.wireframe)
         self.wireframe_box.toggled.connect(self.update_wireframe)
         layout.addWidget(self.wireframe_box)
-        
+
         # Enable lighting toggle
         self.lighting_box = QCheckBox("Enable Lighting")
         self.lighting_box.setChecked(self.enable_lighting)
         self.lighting_box.toggled.connect(self.update_enable_lighting)
         layout.addWidget(self.lighting_box)
-    
-        # Line width control
-        line_width_label = QLabel("Line Width:")
-        layout.addWidget(line_width_label)
-        self.line_width_box = QDoubleSpinBox()
-        self.line_width_box.setRange(0.5, 5.0)
-        self.line_width_box.setSingleStep(0.5)
-        self.line_width_box.setValue(self.line_width)
-        self.line_width_box.valueChanged.connect(self.update_line_width)
-        layout.addWidget(self.line_width_box)
-        
-        # Alpha control
-        alpha_label = QLabel("Alpha:")
-        layout.addWidget(alpha_label)
-        alpha_box = QDoubleSpinBox()
-        alpha_box.setRange(0.0, 1.0)
-        alpha_box.setSingleStep(0.05)
-        alpha_box.setValue(self.alpha)
-        alpha_box.valueChanged.connect(self.update_alpha)
-        layout.addWidget(alpha_box)
-        
-
-        # Color mode selection
-        label_color = QLabel("Color Mode:")
-        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)
 
         label_rgb = QLabel("Color:")
         label_rgb.setToolTip("Use hex color, i.e. #FF4500, or named color, i.e. 'red'")
@@ -162,7 +89,6 @@ class MeshItem(BaseItem):
         self.edit_rgb.textChanged.connect(self._on_color)
         layout.addWidget(self.edit_rgb)
 
-
         # Material property controls for Phong lighting
         if self.enable_lighting:
             # Ambient strength control (slider 0-100 mapped to 0.0-1.0)
@@ -221,12 +147,6 @@ class MeshItem(BaseItem):
         except ValueError:
             pass
 
-    def _on_color_mode(self, index):
-        print(f"Color mode1 : {index}")
-        self.color_mode = index
-        self.edit_rgb.setVisible(index == self.mode_table['FLAT'])
-        self.need_update_setting = True
-
     def update_wireframe(self, value):
         self.wireframe = value
         
@@ -258,135 +178,233 @@ class MeshItem(BaseItem):
         """Update mesh alpha (opacity)"""
         self.alpha = float(value)
         self.need_update_setting = True
-            
-    def set_data(self, verts, faces, colors=None):
+
+    def set_data(self, data):
+        """
+        Set complete mesh data at once.
+        
+        Args:
+            data: is Nx3 numpy array (N must be divisible by 3) or dict
+            if is dict, uses the dict format: 
+            [face_key: (v0.x, v0.y, v0.z, ..., v3.z, good)]
+        """
+        self.clear_mesh()
+
+        if isinstance(data, dict):
+            # Use dict format directly (from get_mesh_data/get_incremental_mesh_data)
+            self.set_incremental_data(data)
+            return
+                
+        # Check if Nx3 array
+
+        if not isinstance(data, np.ndarray):
+            raise ValueError("Invalid data type")
+
+        good_format = False
+        if data.ndim == 2 and \
+            data.shape[1] == 3 and \
+            data.shape[0] % 3 == 0:
+            good_format = True
+
+        if not good_format:
+            raise ValueError("Invalid data shape")
+
+        # Convert to Nx13 numpy array
+        N = data.shape[0] // 3
+        faces = np.zeros((N, 13), dtype=np.float32)
+        tmp = data.reshape(N, 9)
+        faces[:, 0:3]  = tmp[:, 0:3]   # copy v0
+        faces[:, 3:6]  = tmp[:, 3:6]   # copy v1
+        faces[:, 6:9]  = tmp[:, 6:9]   # copy v2
+        faces[:, 9:12] = tmp[:, 6:9]   # copy v3 from v2 (degenerate quad)
+        faces[:, 12] = 1.0             # set good=1.0
+        self.faces = faces
+        self.valid_f_top = N
+
+
+    def set_incremental_data(self, fs):
         """
-        verts: np.ndarray of shape (N, 3)
-        faces: np.ndarray of shape (M, 3) with uint32 indices
-        colors: np.ndarray of shape (N,) with uint32 IRGB format (optional)
-                uint32 contains: I (bits 24-31), R (bits 16-23), G (bits 8-15), B (bits 0-7)
+        Incrementally update mesh with new face data.
+        Args:
+            fs: Dict {face_key: (v0.x, v0.y, v0.z, v1.x, v1.y, v1.z, 
+                                  v2.x, v2.y, v2.z, v3.x, v3.y, v3.z, good), ...}
+                13-tuple with vertex positions and good flag (0.0 or 1.0)
+                If good==1:
+                    Triangle 1: (v0, v1, v3)
+                    Triangle 2: (v0, v3, v2)
+        Updates:
+            - faces: updates existing faces or appends new ones
+            - key2index: tracks face_key -> face_index mapping
         """
-        verts = np.asarray(verts, dtype=np.float32)
-        faces = np.asarray(faces, dtype=np.uint32)
-        triangles = verts[faces.flatten()]
-
-        if colors is not None:
-            colors = np.asarray(colors, dtype=np.uint32)
-            if len(colors) == len(verts):
-                # Expand per-vertex colors to per-triangle-vertex
-                self.vertex_colors = colors[faces.flatten()]
+        if not fs:
+            return
+
+        # Ensure enough capacity in faces buffer
+        # wasted cases are better than frequent expansions
+        while self.valid_f_top + len(fs) > len(self.faces):
+            self._expand_face_buffer()
+
+        # Optimization: Separate updates from new insertions to avoid
+        # dictionary lookup performance degradation during growth
+        update_idxs = []   # [idx, ...]
+        update_data = []   # [face_data, ...]
+        new_keys = []      # [key, ...]
+        new_data = []      # [face_data, ...]
+
+        for face_key, face_data in fs.items():
+            face_idx = self.key2index.get(face_key)
+            if face_idx is not None:
+                update_idxs.append(face_idx)
+                update_data.append(face_data)
             else:
-                self.vertex_colors = None
-        else:
-            self.vertex_colors = None
-            
-        self.triangles = np.asarray(triangles, dtype=np.float32)
-        self.normals = self.calculate_normals()
-        self.need_update_buffer = True
-        
-    def calculate_normals(self):
-        if self.triangles is None or len(self.triangles) == 0:
-            return None
-            
-        # Ensure we have complete triangles
-        num_vertices = len(self.triangles)
-        num_triangles = num_vertices // 3
-        if num_triangles == 0:
-            return None
-            
-        # Reshape vertices into triangles (N, 3, 3) where N is number of triangles
-        vertices_reshaped = self.triangles[:num_triangles * 3].reshape(-1, 3, 3)
-        
-        v0 = vertices_reshaped[:, 0, :]
-        v1 = vertices_reshaped[:, 1, :]
-        v2 = vertices_reshaped[:, 2, :]
-        
-        # Calculate edges for all triangles at once
-        edge1 = v1 - v0
-        edge2 = v2 - v0
-        
-        face_normals = np.cross(edge1, edge2)
-        
-        norms = np.linalg.norm(face_normals, axis=1, keepdims=True)
-        norms[norms < 1e-6] = 1.0
-        face_normals = face_normals / norms
-        
-        normals_per_vertex = np.repeat(face_normals[:, np.newaxis, :], 3, axis=1)
-        normals = normals_per_vertex.reshape(-1, 3)        
-        return normals.astype(np.float32)
+                new_keys.append(face_key)
+                new_data.append(face_data)
+
+        # Batch update existing faces
+        if update_data:
+            indices = np.array(update_idxs, dtype=np.int32)
+            data = np.array(update_data, dtype=np.float32)
+            self.faces[indices] = data
+        
+        # Batch insert new faces
+        if new_data:
+            n_new = len(new_data)
+            data = np.array(new_data, dtype=np.float32)
+            self.faces[self.valid_f_top: self.valid_f_top + n_new] = data
+
+            # Update key2index mapping for new faces
+            for i, face_key in enumerate(new_keys):
+                self.key2index[face_key] = self.valid_f_top + i
             
+            self.valid_f_top += n_new
+    
+    def _expand_face_buffer(self):
+        """Expand the faces buffer when capacity is reached"""
+        new_capacity = len(self.faces) + self.FACE_CAPACITY
+        new_buffer = np.zeros((new_capacity, 13), dtype=np.float32)
+        new_buffer[:len(self.faces)] = self.faces
+        self.faces = new_buffer
+    
+    def clear_mesh(self):
+        """Clear all mesh data and reset buffers"""
+        self.valid_f_top = 0
+        self.key2index.clear()
+        if hasattr(self, 'indices_array'):
+            self.indices_array = np.array([], dtype=np.uint32)
+
     def initialize_gl(self):
         """OpenGL initialization"""
-        vertex_shader = open(self.path + '/../shaders/mesh_vert.glsl', 'r').read()
-        fragment_shader = open(self.path + '/../shaders/mesh_frag.glsl', 'r').read()
-
-        program = shaders.compileProgram(
-            shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
-            shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER),
-        )
-        self.program = program
+        # Use instanced mesh shaders with geometry shader for GPU-side triangle generation
+        vert_shader = open(self.path + '/../shaders/mesh_vert.glsl', 'r').read()
+        geom_shader = open(self.path + '/../shaders/mesh_geom.glsl', 'r').read()
+        frag_shader = open(self.path + '/../shaders/mesh_frag.glsl', 'r').read()
+        try:
+            program = shaders.compileProgram(
+                shaders.compileShader(vert_shader, GL_VERTEX_SHADER),
+                shaders.compileShader(geom_shader, GL_GEOMETRY_SHADER),
+                shaders.compileShader(frag_shader, GL_FRAGMENT_SHADER),
+            )
+            self.program = program
+        except Exception as e:
+            raise
 
     def update_render_buffer(self):
-        """Initialize OpenGL buffers"""
-        if not self.need_update_buffer:
+        """
+        Update GPU buffer with face data (no separate vertex buffer).
+        Each face contains embedded vertex positions (13 floats).
+        Geometry shader generates triangles on GPU from face vertices.
+        Dynamically resizes GPU buffer when Python buffer expands.
+        """
+        if self.valid_f_top == 0:
             return
-            
-        # Generate VAO and VBOs
+        
+        # Initialize buffers on first call
         if self.vao is None:
             self.vao = glGenVertexArrays(1)
-            self.vbo_vertices = glGenBuffers(1)
-            self.vbo_normals = glGenBuffers(1)
-            self.vbo_colors = glGenBuffers(1)
-        
-        glBindVertexArray(self.vao)
-        
-        # Vertex buffer
-        glBindBuffer(GL_ARRAY_BUFFER, self.vbo_vertices)
-        glBufferData(GL_ARRAY_BUFFER, self.triangles.nbytes, self.triangles, GL_STATIC_DRAW)
-        glEnableVertexAttribArray(0)
-        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
-        
-        # Normal buffer
-        if self.normals is not None:
-            glBindBuffer(GL_ARRAY_BUFFER, self.vbo_normals)
-            glBufferData(GL_ARRAY_BUFFER, self.normals.nbytes, self.normals, GL_STATIC_DRAW)
+            self.vbo = glGenBuffers(1)
+            self._gpu_face_capacity = 0
+        
+        # Check if we need to reallocate VBO for faces
+        if self._gpu_face_capacity < len(self.faces):
+            glBindVertexArray(self.vao)
+            glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+            glBufferData(GL_ARRAY_BUFFER,
+                        self.faces.nbytes,
+                        None,
+                        GL_DYNAMIC_DRAW)
+            
+            # Setup face attributes (per-instance)
+            # Face data: [v0.x, v0.y, v0.z, v1.x, v1.y, v1.z, v2.x, v2.y, v2.z, v3.x, v3.y, v3.z, good]
+            # 13 floats = 52 bytes stride
+            
+            # v0 (location 1) - vec3
             glEnableVertexAttribArray(1)
-            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, None)
-        
-        # Color buffer (uint32 IRGB format)
-        if self.vertex_colors is not None:
-            glBindBuffer(GL_ARRAY_BUFFER, self.vbo_colors)
-            glBufferData(GL_ARRAY_BUFFER, self.vertex_colors.nbytes, self.vertex_colors, GL_STATIC_DRAW)
+            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 52, ctypes.c_void_p(0))
+            glVertexAttribDivisor(1, 1)
+            
+            # v1 (location 2) - vec3
             glEnableVertexAttribArray(2)
-            glVertexAttribIPointer(2, 1, GL_UNSIGNED_INT, 0, None)
-        
-        glBindVertexArray(0)
-        self.need_update_buffer = False
+            glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 52, ctypes.c_void_p(12))
+            glVertexAttribDivisor(2, 1)
+            
+            # v2 (location 3) - vec3
+            glEnableVertexAttribArray(3)
+            glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 52, ctypes.c_void_p(24))
+            glVertexAttribDivisor(3, 1)
+            
+            # v3 (location 4) - vec3
+            glEnableVertexAttribArray(4)
+            glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 52, ctypes.c_void_p(36))
+            glVertexAttribDivisor(4, 1)
+            
+            # good flag (location 5) - float
+            glEnableVertexAttribArray(5)
+            glVertexAttribPointer(5, 1, GL_FLOAT, GL_FALSE, 52, ctypes.c_void_p(48))
+            glVertexAttribDivisor(5, 1)
+            
+            glBindVertexArray(0)
+            glBindBuffer(GL_ARRAY_BUFFER, 0)
+            self._gpu_face_capacity = len(self.faces)
+        
+        # Upload faces to VBO
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        glBufferSubData(GL_ARRAY_BUFFER,
+                       0,
+                       self.valid_f_top * 13 * 4,  # 13 floats * 4 bytes per face
+                       self.faces[:self.valid_f_top])
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
         
     def update_setting(self):
-        if (self.need_update_setting is False):
+        """Set fixed rendering parameters (called once during initialization)"""
+        if not self.need_update_setting:
             return
+        # Set fixed uniforms for instanced shaders
         set_uniform(self.program, int(self.enable_lighting), 'if_light')
         set_uniform(self.program, 1, 'two_sided')
-        set_uniform(self.program, np.array(self.light_color), 'light_color')
+
+        set_uniform(self.program, np.array(self.light_color, dtype=np.float32), 'light_color')
         set_uniform(self.program, float(self.ambient_strength), 'ambient_strength')
         set_uniform(self.program, float(self.diffuse_strength), 'diffuse_strength')
         set_uniform(self.program, float(self.specular_strength), 'specular_strength')
         set_uniform(self.program, float(self.shininess), 'shininess')
         set_uniform(self.program, float(self.alpha), 'alpha')
         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.vmin), 'vmin')
-        set_uniform(self.program, float(self.vmax), 'vmax')
         self.need_update_setting = False
 
     def paint(self):
-        """Render the mesh using modern OpenGL with shaders"""
-        if self.triangles is None or len(self.triangles) == 0:
+        """
+        Render the mesh using instanced rendering with geometry shader.
+        Each face instance is rendered as a point, geometry shader generates 2 triangles.
+        GPU filters faces based on good flag.
+        """
+        if self.valid_f_top == 0:
             return
+        
         glUseProgram(self.program)
+    
         self.update_render_buffer()
         self.update_setting()
+        
         view_matrix = self.glwidget().view_matrix
         set_uniform(self.program, view_matrix, 'view')
         project_matrix = self.glwidget().projection_matrix
@@ -394,30 +412,29 @@ class MeshItem(BaseItem):
         view_pos = self.glwidget().center
         set_uniform(self.program, np.array(view_pos), 'view_pos')
             
-        
         # Enable blending and depth testing
         glEnable(GL_BLEND)
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
         glEnable(GL_DEPTH_TEST)
         glDisable(GL_CULL_FACE)  # two-sided rendering
-
+        
         # Set line width
         glLineWidth(self.line_width)
         
-        # Bind VAO and render
+        # Bind VAO (vertex positions are now in VBO attributes)
         glBindVertexArray(self.vao)
-        
-        if len(self.triangles) > 0:
-            # Render faces
-            if self.wireframe:
-                glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
-            else:
-                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
                 
-            # Draw triangles
-            glDrawArrays(GL_TRIANGLES, 0, len(self.triangles))
+        if self.wireframe:
+            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+        else:
             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
-                
+        
+        # Draw using instanced rendering
+        # Input: POINTS (one per face instance)
+        # Geometry shader generates 2 triangles (6 vertices) per point
+        glDrawArraysInstanced(GL_POINTS, 0, 1, self.valid_f_top)
+            
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
         glBindVertexArray(0)
         glDisable(GL_DEPTH_TEST)
         glDisable(GL_BLEND)

q3dviewer/glwidget.py

@@ -55,6 +55,7 @@ class GLWidget(BaseGLWidget):
         self.followable_item_name = None
         self.setting_window = SettingWindow()
         self.enable_show_center = True
+        self.old_center = None
         super(GLWidget, self).__init__()
 
     def keyPressEvent(self, ev: QKeyEvent):
@@ -63,14 +64,38 @@ class GLWidget(BaseGLWidget):
             self.open_setting_window()            
         else:
             super().keyPressEvent(ev)
+        if ev.key() == QtCore.Qt.Key_F:  # reset follow
+            if self.followable_item_name is None:
+                self.initial_followable()
+
+            if self.followed_name != 'none':
+                self.followed_name = 'none'
+                print("Reset follow.")
+            elif len(self.followable_item_name) > 1:
+                self.followed_name = self.followable_item_name[1]
+                print("Set follow to ", self.followed_name)
+            else:
+                pass # do nothing
 
     def on_followable_selection(self, index):
         self.followed_name = self.followable_item_name[index]
 
+    def mouseDoubleClickEvent(self, event):
+        """Double click to set center."""
+        p = self.get_point(event.x(), event.y())
+        if p is not None:
+            self.set_center(p)
+        super().mouseDoubleClickEvent(event)
+
     def update(self):
         if self.followed_name != 'none':
             new_center = self.named_items[self.followed_name].T[:3, 3]
-            self.set_center(new_center)
+            if self.old_center is None:
+                self.old_center = self.center
+                return
+            delta = new_center - self.old_center
+            self.set_center(self.center + delta)
+            self.old_center = new_center
         super().update()
 
     def add_setting(self, layout):

q3dviewer/shaders/cloud_vert.glsl

@@ -66,7 +66,7 @@ void main()
     {
         uint intensity = value >> 24;
         float range = vmax - vmin;
-        float value = 1.0 - (float(intensity) - vmin) / range;
+        float value = (float(intensity) - vmin) / range;
         c.z = value;
         c.y = value;
         c.x = value;

q3dviewer/shaders/mesh_geom.glsl

@@ -0,0 +1,83 @@
+#version 430 core
+
+/*
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+*/
+
+layout(points) in;
+layout(triangle_strip, max_vertices = 6) out;
+
+// Input from vertex shader
+in VS_OUT {
+    vec3 v0, v1, v2, v3;
+    float good;
+} gs_in[];
+
+// Uniforms
+uniform mat4 view;
+uniform mat4 projection;
+
+uniform int flat_rgb;
+
+
+// Output to fragment shader
+out vec3 FragPos;
+out vec3 Normal;
+out vec3 objectColor;
+
+// Calculate normal from three vertices
+vec3 calculateNormal(vec3 a, vec3 b, vec3 c) {
+    vec3 edge1 = b - a;
+    vec3 edge2 = c - a;
+    return normalize(cross(edge1, edge2));
+}
+
+void emitVertex(vec3 pos, vec3 normal, vec3 color) {
+    FragPos = pos;
+    Normal = normal;
+    objectColor = color;
+    gl_Position = projection * view * vec4(pos, 1.0);
+    EmitVertex();
+}
+
+void main()
+{
+    // Discard if face is not good
+    if (gs_in[0].good != 1.0) {
+        return;
+    }
+    
+    vec3 v0 = gs_in[0].v0;
+    vec3 v1 = gs_in[0].v1;
+    vec3 v2 = gs_in[0].v2;
+    vec3 v3 = gs_in[0].v3;
+    
+    float eps = 0.0001;
+    
+    // Use default light blue color
+    vec3 color = vec3(
+        float((uint(flat_rgb) & uint(0x00FF0000)) >> 16)/255.,
+        float((uint(flat_rgb) & uint(0x0000FF00)) >> 8)/255.,
+        float( uint(flat_rgb) & uint(0x000000FF))/255.
+    );
+    // Triangle 1: (v0, v1, v2)
+    vec3 normal1 = calculateNormal(v0, v1, v2);
+    // Skip degenerate triangles
+    if (length(normal1) > eps) {
+        emitVertex(v0, normal1, color);
+        emitVertex(v1, normal1, color);
+        emitVertex(v2, normal1, color);
+        EndPrimitive();
+    }
+    
+    // Triangle 2: (v0, v1, v3)
+    vec3 normal2 = calculateNormal(v0, v1, v3);
+    // Skip degenerate triangles
+    if (length(normal2) > eps) {
+        emitVertex(v0, normal2, color);
+        emitVertex(v1, normal2, color);
+        emitVertex(v3, normal2, color);
+        EndPrimitive();
+    }
+}

q3dviewer/shaders/mesh_vert.glsl

@@ -1,65 +1,37 @@
-#version 330 core
-layout (location = 0) in vec3 aPos;
-layout (location = 1) in vec3 aNormal;
-layout (location = 2) in uint aColor;
+#version 430 core
 
-out vec3 FragPos;
-out vec3 Normal;
-out vec3 objectColor;
+/*
+Copyright 2024 Panasonic Advanced Technology Development Co.,Ltd. (Liu Yang)
+Distributed under MIT license. See LICENSE for more information.
+*/
 
+// Face attributes (per-instance) - vertex positions embedded in each face
+layout(location = 1) in vec3 v0;
+layout(location = 2) in vec3 v1;
+layout(location = 3) in vec3 v2;
+layout(location = 4) in vec3 v3;
+layout(location = 5) in float good;
+
+// Uniforms
 uniform mat4 view;
 uniform mat4 projection;
-uniform int flat_rgb;
-uniform int color_mode;  // 0: FLAT, 1: Intensity, 2: RGB
-uniform float vmin;
-uniform float vmax;
-
-vec3 getRainbowColor(uint value_raw) {
-    float range = vmax - vmin;
-    float value = 1.0 - (float(value_raw) - vmin) / range;
-    value = clamp(value, 0.0, 1.0);
-    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;
-    float n = 1.0 - f;
 
-    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 color = vec3(1.0, n, 0.0);
-    return color;
-}
+// Outputs to fragment shader (via geometry shader)
+out VS_OUT {
+    vec3 v0, v1, v2, v3;
+    float good;
+} vs_out;
 
 void main()
 {
-    FragPos = aPos;
-    Normal = aNormal;
-    
-    vec3 c = vec3(1.0, 1.0, 1.0);
+    // Pass vertex positions directly (no SSBO lookup needed)
+    vs_out.v0 = v0;
+    vs_out.v1 = v1;
+    vs_out.v2 = v2;
+    vs_out.v3 = v3;
+    vs_out.good = good;
     
-    if (color_mode == 0) {
-        // FLAT: use uniform flat color
-        c.z = float( uint(flat_rgb) & uint(0x000000FF))/255.;
-        c.y = float((uint(flat_rgb) & uint(0x0000FF00)) >> 8)/255.;
-        c.x = float((uint(flat_rgb) & uint(0x00FF0000)) >> 16)/255.;
-    }
-    else if (color_mode == 1) {
-        // Intensity: use intensity channel (bits 24-31) for rainbow color
-        uint intensity = aColor >> 24;
-        c = getRainbowColor(intensity);
-    }
-    else if (color_mode == 2) {
-        // RGB: use RGB channels (bits 0-23)
-        c.z = float(aColor & uint(0x000000FF))/255.;
-        c.y = float((aColor & uint(0x0000FF00)) >> 8)/255.;
-        c.x = float((aColor & uint(0x00FF0000)) >> 16)/255.;
-    }
-    
-    objectColor = c;
-    
-    // Final vertex position (apply view/projection)
-    gl_Position = projection * view * vec4(aPos, 1.0);
-}
+    // Output dummy point (geometry shader will generate triangles)
+    // Note: This position is not used; geometry shader generates actual triangles
+    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+}

q3dviewer/tools/cloud_viewer.py

@@ -7,39 +7,29 @@ Distributed under MIT license. See LICENSE for more information.
 
 import numpy as np
 import q3dviewer as q3d
-from q3dviewer.Qt.QtWidgets import QVBoxLayout, QProgressBar, QDialog, QLabel
+from q3dviewer.Qt.QtWidgets import QVBoxLayout, QDialog, QLabel
 from q3dviewer.Qt.QtCore import QThread, Signal, Qt
-from q3dviewer.Qt.QtGui import QKeyEvent
 from q3dviewer import GLWidget
 
-
-class ProgressDialog(QDialog):
+class ProgressWindow(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("Loading Cloud File")
+        self.setWindowTitle("Loading")
         self.setModal(True)
-        self.progress_bar = QProgressBar(self)
-        self.file_label = QLabel(self)
+        self.setMinimumWidth(400)
+        self.label = QLabel(self)
+        self.label.setAlignment(Qt.AlignCenter)
         layout = QVBoxLayout()
-        layout.addWidget(self.file_label)
-        layout.addWidget(self.progress_bar)
+        layout.addWidget(self.label)
         self.setLayout(layout)
 
-    def set_value(self, value):
-        self.progress_bar.setValue(value)
-
-    def set_file_name(self, file_name):
-        self.file_label.setText(f"Loading: {file_name}")
-
-    def closeEvent(self, event):
-        if self.parent().progress_thread and self.parent().progress_thread.isRunning():
-            event.ignore()
-        else:
-            event.accept()
+    def update_progress(self, current, total, file_name):
+        text = f"[{current}/{total}] loading file: {file_name}"
+        self.label.setText(text)
 
 
 class FileLoaderThread(QThread):
-    progress = Signal(int)
+    progress = Signal(int, int, str)  # current, total, filename
     finished = Signal()
 
     def __init__(self, viewer, files):
@@ -50,25 +40,22 @@ class FileLoaderThread(QThread):
     def run(self):
         cloud_item = self.viewer['cloud']
         mesh_item = self.viewer['mesh']
+        total = len(self.files)
         for i, url in enumerate(self.files):
             # if the file is a mesh file, use mesh_item to load
             file_path = url.toLocalFile()
-            file_path = url.toLocalFile()
-            self.viewer.progress_dialog.set_file_name(file_path)
+            import os
+            file_name = os.path.basename(file_path)
+            self.progress.emit(i + 1, total, file_name)
+            
             if url.toLocalFile().lower().endswith(('.stl')):
                 from q3dviewer.utils.cloud_io import load_stl
-                verts, faces = load_stl(file_path)
-                # create colors, N, array
-                color = np.zeros((verts.shape[0],), dtype=np.uint32)
-                # random uint32 colors in IRGB format
-                color = np.random.randint(0, 0xFFFFFFFF, size=(verts.shape[0],), dtype=np.uint32)
-                mesh_item.set_data(verts=verts, faces=faces, colors=color)
-                break
+                mesh = load_stl(file_path)
+                mesh_item.set_data(mesh)
             else:
                 cloud = cloud_item.load(file_path, append=(i > 0))
                 center = np.nanmean(cloud['xyz'].astype(np.float64), axis=0)
                 self.viewer.glwidget.set_cam_position(center=center)
-                self.progress.emit(int((i + 1) / len(self.files) * 100))
         self.finished.emit()
 
 
@@ -135,20 +122,19 @@ class CloudViewer(q3d.Viewer):
         """
         Overwrite the drop event to open the cloud file.
         """
-        self.progress_dialog = ProgressDialog(self)
-        self.progress_dialog.show()
+        self.progress_window = ProgressWindow(self)
+        self.progress_window.show()
         files = event.mimeData().urls()
         self.progress_thread = FileLoaderThread(self, files)
-        self['cloud'].load(files[0].toLocalFile(), append=False)
         self.progress_thread.progress.connect(self.file_loading_progress)
         self.progress_thread.finished.connect(self.file_loading_finished)
         self.progress_thread.start()
 
-    def file_loading_progress(self, value):
-        self.progress_dialog.set_value(value)
+    def file_loading_progress(self, current, total, file_name):
+        self.progress_window.update_progress(current, total, file_name)
 
     def file_loading_finished(self):
-        self.progress_dialog.close()
+        self.progress_window.close()
 
     def open_cloud_file(self, file, append=False):
         cloud_item = self['cloud']
@@ -159,27 +145,50 @@ class CloudViewer(q3d.Viewer):
         center = np.nanmean(cloud['xyz'].astype(np.float64), axis=0)
         self.glwidget.set_cam_position(center=center)
 
-# print a quick help message
+# print a quick help message using rich
 def print_help():
-    # ANSI color codes
-    GREEN = '\033[92m'
-    BLUE = '\033[94m'
-    BOLD = '\033[1m'
-    END = '\033[0m'
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.text import Text
+    
+    console = Console()
+    
+    # Create a table for better organization
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column(style="bold cyan", width=30)
+    table.add_column(style="white")
+    
+    # File loading section
+    table.add_row("📁 Load Files","Drag and drop files into the viewer")
+    table.add_row("","[dim]• Point clouds: .pcd, .ply, .las, .e57[/dim]")
+    table.add_row("","[dim]• Mesh files: .stl[/dim]")
+    table.add_row("", "")
+    
+    # Measurement section
+    table.add_row("📏 Measure Distance", "Interactive point measurement")
+    table.add_row("","[dim]• Ctrl + Left Click: Add measurement point[/dim]")
+    table.add_row("","[dim]• Ctrl + Right Click: Remove last point[/dim]")
+    table.add_row("","[dim]• Total distance displayed automatically[/dim]")
+    table.add_row("", "")
+    
+    # Camera controls
+    table.add_row("🎥 Camera Controls","Navigate the 3D scene")
+    table.add_row("","[dim]• Double Click: Set camera center to point[/dim]")
+    table.add_row("","[dim]• Right Drag: Rotate view[/dim]")
+    table.add_row("","[dim]• Left Drag: Pan view[/dim]")
+    table.add_row("","[dim]• Mouse Wheel: Zoom in/out[/dim]")
+    table.add_row("", "")
+    
+    # Settings section
+    table.add_row("⚙️  Settings","Press [bold green]'M'[/bold green] to open settings window")
+    table.add_row("","[dim]Adjust visualization properties[/dim]")
     
-    help_msg = f"""
-{BOLD}Cloud Viewer Help:{END}
-{GREEN}• Drag and drop cloud files into the viewer to load them.{END}
-    {BLUE}- support .pcd, .ply, .las, .e57, for point clouds.{END}
-    {BLUE}- support .stl for mesh files.{END}
-{GREEN}• Measure distance between points:{END}
-    {BLUE}- Hold Ctrl and left-click to select points on the cloud.{END}
-    {BLUE}- Hold Ctrl and right-click to remove the last selected point.{END}
-    {BLUE}- The total distance between selected points will be displayed.{END}
-{GREEN}• Press 'M' to open the settings window.{END}
-    {BLUE}- Use the settings window to adjust item properties.{END}
-    """
-    print(help_msg)
+    # Print title and table without border
+    console.print()
+    console.print("[bold magenta]☁️  Cloud Viewer Help[/bold magenta]\n")
+    console.print(table)
+    console.print()
 
 def main():
     print_help()

q3dviewer/utils/cloud_io.py

@@ -7,25 +7,52 @@ import numpy as np
 
 
 def load_stl(file_path):
-    from stl import mesh as stlmesh
-    m = stlmesh.Mesh.from_file(file_path)
-    verts = m.vectors.reshape(-1, 3).astype(np.float32)
-    faces = np.arange(len(verts), dtype=np.uint32).reshape(-1, 3)
-    return verts, faces
-
-
-def save_stl(verts, faces, save_path):
-    """Save the generated mesh as an STL file."""
-    from stl import mesh as stlmesh
-    from stl import Mode
-    verts = np.asarray(verts, dtype=np.float32)
-    faces = np.asarray(faces, dtype=np.uint32)
-    # Create the mesh
-    m = stlmesh.Mesh(np.zeros(faces.shape[0], dtype=stlmesh.Mesh.dtype))
-    m.vectors[:] = verts[faces].astype(np.float32)
-    # Save to file
-    m.save(save_path, mode=Mode.BINARY)
-
+    import meshio
+    mesh = meshio.read(file_path)
+    # meshio returns cells as a list of (cell_type, cell_data) tuples
+    # For STL, we expect 'triangle' cells
+    vertices = mesh.points.astype(np.float32)
+    
+    # Find triangle cells
+    triangles = None
+    for cell_block in mesh.cells:
+        if cell_block.type == 'triangle':
+            triangles = cell_block.data
+            break
+    
+    if triangles is None:
+        raise ValueError(f"No triangle cells found in STL file: {file_path}")
+    
+    # Convert indexed triangles to flat vertex array (N*3, 3)
+    faces = vertices[triangles.flatten()].astype(np.float32)
+    return faces
+
+
+def save_stl(faces, save_path, binary=True):
+    import meshio
+    faces = np.asarray(faces, dtype=np.float32)
+    if faces.shape[0] % 3 != 0:
+        raise ValueError(f"Invalid faces shape: {faces.shape}, must be (N*3, 3)")
+    
+    # Reshape to (num_triangles, 3, 3)
+    num_triangles = faces.shape[0] // 3
+    triangles = faces.reshape(num_triangles, 3, 3)
+    
+    # Get unique vertices and create index array
+    vertices, indices = np.unique(triangles.reshape(-1, 3), axis=0, return_inverse=True)
+    triangle_indices = indices.reshape(num_triangles, 3)
+    
+    # Create meshio mesh object
+    mesh = meshio.Mesh(
+        points=vertices,
+        cells=[("triangle", triangle_indices)]
+    )
+    # meshio automatically saves STL as binary by default
+    # Use file_format="stl-ascii" for ASCII format
+    if binary:
+        mesh.write(save_path, binary=True)
+    else:
+        mesh.write(save_path, binary=False)
 
 def save_ply(cloud, save_path):
     import meshio

{q3dviewer-1.2.2.dist-info → q3dviewer-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.2.2
+Version: 1.2.3
 Summary: A library designed for quickly deploying a 3D viewer.
 Home-page: https://github.com/scomup/q3dviewer
 Author: Liu Yang
@@ -17,7 +17,6 @@ Requires-Dist: laspy
 Requires-Dist: matplotlib
 Requires-Dist: meshio
 Requires-Dist: numpy
-Requires-Dist: numpy-stl
 Requires-Dist: pye57
 Requires-Dist: pypcd4
 Requires-Dist: pyside6

{q3dviewer-1.2.2.dist-info → q3dviewer-1.2.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 q3dviewer/__init__.py,sha256=cjyfUE5zK6xohDGDQIWfb0DKkWChVznBd7CrVLg7whQ,376
 q3dviewer/base_glwidget.py,sha256=QxAuZzQSBbzTwpHHqYpiM-Jqv41E4YJmFG4KRF-HruY,15274
 q3dviewer/base_item.py,sha256=63MarHyoWszPL40ox-vPoOAQ1N4ypekOjoRARdPik-E,1755
-q3dviewer/glwidget.py,sha256=EmrxPtVQ8RdPK5INKMlpKpVfX0KCfjSKRdGf4cSB1f0,5405
+q3dviewer/glwidget.py,sha256=taewDTQUqmKOrDYz_ygghu00dlCnWzFRpDnEaTG25pA,6390
 q3dviewer/viewer.py,sha256=Vq3ucDlBcBBoiVVGmqG1sRjhLePl50heblx6wJpsc1A,2603
 q3dviewer/Qt/__init__.py,sha256=VJj7Ge6N_81__T9eHFl_YQpa1HyQrlLhMqC_9pUOYtc,2233
 q3dviewer/custom_items/__init__.py,sha256=kaaf84wOObfybJ8a12FqPMeg8ImTJWggA6g5nvpY2YY,621
@@ -13,19 +13,20 @@ q3dviewer/custom_items/gaussian_item.py,sha256=JMubpahkTPh0E8ShL3FLTahv0e35ODzjg
 q3dviewer/custom_items/grid_item.py,sha256=LDB_MYACoxld-xvz01_MfAf12vLcRkH7R_WtGHHdSgk,4945
 q3dviewer/custom_items/image_item.py,sha256=k7HNTqdL2ckTbxMx7A7eKaP4aksZ85-pBjNdbpm6PXM,5355
 q3dviewer/custom_items/line_item.py,sha256=rel-lx8AgjDY7qyIecHxHQZzaswRn2ZTiOIjB_0Mrqo,4444
-q3dviewer/custom_items/mesh_item.py,sha256=Ds3GyYzvFF5VpjG-_LU9SNZiBoLmztCZrkcalEMjub8,17890
+q3dviewer/custom_items/mesh_item.py,sha256=L6GzCcxiAkeYMLBUbbTvQgY0s-maCYQZqZqeMDtxuFE,17568
 q3dviewer/custom_items/text3d_item.py,sha256=DYBPXnCmMEzWDE1y523YsWSl91taXAdu0kdnhUcwE4A,5524
 q3dviewer/custom_items/text_item.py,sha256=toeGjBu7RtT8CMUuaDWnmXPnA1UKHhnCzUNeonGczSo,2703
 q3dviewer/shaders/cloud_frag.glsl,sha256=psKVt9qI6BW0bCqOk4lcKqUd6XgYGtdFigyN9OdYSNI,609
-q3dviewer/shaders/cloud_vert.glsl,sha256=gKI6EJrzX5ga2W2yjU6x7Wjz7Cu2Y-wrPl4g10RfTLM,2376
+q3dviewer/shaders/cloud_vert.glsl,sha256=7tNkdx0iuoq1sG3YZ1UuF2JOhEohcodZ363WUV2B2Q4,2370
 q3dviewer/shaders/gau_frag.glsl,sha256=vWt5I3Ojrc2PCxRlBJGyJhujbveSicMA54T01Fk293A,975
 q3dviewer/shaders/gau_prep.glsl,sha256=0BiWhYCQGeX2iN-e7m3dy1xWXqWrErErRAzHlcmWHF0,7218
 q3dviewer/shaders/gau_vert.glsl,sha256=_rkm51zaWgPDJ-otJL-WX12fDvnPBOTooVfqo21Rexs,1666
 q3dviewer/shaders/mesh_frag.glsl,sha256=i9ljnO2kjLNGaR1TPQIK4-4iJ-JppJ5bCsOHg1730gQ,1997
-q3dviewer/shaders/mesh_vert.glsl,sha256=tj9pbaWUYoKn1CtYahahPVzXNDTEtaQanq3S3VphmPg,1896
+q3dviewer/shaders/mesh_geom.glsl,sha256=HwNEZy7UAQm-PKEP-LnqHTlsSqZ5eqm49CYZSVylzXk,1964
+q3dviewer/shaders/mesh_vert.glsl,sha256=bFg7HXesdVg7UaGDuZ4g7IpRdSKcfc6jzTcxLjNXkt8,968
 q3dviewer/shaders/sort_by_key.glsl,sha256=M5RK6uRDp40vVH6XtBIrdJTcYatqXyZwd6kCzEa2DZg,1097
 q3dviewer/tools/__init__.py,sha256=01wG7BGM6VX0QyFBKsqPmyf2e-vrmV_N3-mo-VQ1VBg,20
-q3dviewer/tools/cloud_viewer.py,sha256=sZ16uOt5J_3E7H0ZW3NHq0mTkWuoBkRRtwEQgcEv-Io,7794
+q3dviewer/tools/cloud_viewer.py,sha256=wjgQNrn9IzHXd8V2Y45ANm12_YZRaV3uL7F8HkylrN0,8185
 q3dviewer/tools/example_viewer.py,sha256=C867mLnCBjawS6LGgRsJ_c6-6wztfL9vOBQt85KbbdU,572
 q3dviewer/tools/film_maker.py,sha256=xLFgRhFWoMQ37qlvcu1lXWaTWXMNRYlRcZFfHW5JtmQ,16676
 q3dviewer/tools/gaussian_viewer.py,sha256=vIwWmiFhjNmknrEkBLzt2yiegeH7LP3OeNjnGM6GzaI,1633
@@ -33,15 +34,15 @@ q3dviewer/tools/lidar_calib.py,sha256=hHnsSaQh_Pkdh8tPntt0MgEW26nQyAdC_HQHq4I3sw
 q3dviewer/tools/lidar_cam_calib.py,sha256=4CDcZZiFZDeKo2Y2_lXF9tfbiF9dPsz0OjppQdxQsU4,11430
 q3dviewer/tools/ros_viewer.py,sha256=ARB3I5wohY3maP8dCu0O0hxObd6JFKuK2y7AApVgMWA,2551
 q3dviewer/utils/__init__.py,sha256=dwTNAAebTiKY4ygv2G1O-w6-TbJnmnNVO2UfJXvJhaQ,107
-q3dviewer/utils/cloud_io.py,sha256=vU03lT4Y-4oPPTNV137HBw-tfwwCwpcaoz3ENWfIAN4,12837
+q3dviewer/utils/cloud_io.py,sha256=OLmVQWbrnGrlZHPz3zdoVn79r50JhM6V0zV-KwogEU8,13732
 q3dviewer/utils/convert_ros_msg.py,sha256=lNbLIawJfwp3VzygdW3dUXkfSG8atg_CoZbQFmt8H70,3142
 q3dviewer/utils/gl_helper.py,sha256=dRY_kUqyPMr7NTcupUr6_VTvgnj53iE2C0Lk0-oFYsI,1435
 q3dviewer/utils/helpers.py,sha256=SqR4YTQZi13FKbkVUYgodXce1JJ_YmrHEIRkUmnIUas,3085
 q3dviewer/utils/maths.py,sha256=zHaPtvVZIuo8xepIXCMeSL9tpx8FahUrq0l4K1oXrBk,8834
 q3dviewer/utils/range_slider.py,sha256=Cs_xrwt6FCDVxGxan7r-ARd5ySwQ50xnCzcmz0dB_X0,4215
-q3dviewer-1.2.2.dist-info/LICENSE,sha256=81cMOyNfw8KLb1JnPYngGHJ5W83gSbZEBU9MEP3tl-E,1124
-q3dviewer-1.2.2.dist-info/METADATA,sha256=pZQwcgig77nSIonNFabIUAptK75BfyLqrydzgc7FwNg,8049
-q3dviewer-1.2.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-q3dviewer-1.2.2.dist-info/entry_points.txt,sha256=EOjker7XYaBk70ffvNB_knPcfA33Bnlg21ZjEeM1EyI,362
-q3dviewer-1.2.2.dist-info/top_level.txt,sha256=HFFDCbGu28txcGe2HPc46A7EPaguBa_b5oH7bufmxHM,10
-q3dviewer-1.2.2.dist-info/RECORD,,
+q3dviewer-1.2.3.dist-info/LICENSE,sha256=81cMOyNfw8KLb1JnPYngGHJ5W83gSbZEBU9MEP3tl-E,1124
+q3dviewer-1.2.3.dist-info/METADATA,sha256=JjSE7g9HjmxRfl18Z79_EA90drP_EKhBVWuiMYk7yNM,8024
+q3dviewer-1.2.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+q3dviewer-1.2.3.dist-info/entry_points.txt,sha256=EOjker7XYaBk70ffvNB_knPcfA33Bnlg21ZjEeM1EyI,362
+q3dviewer-1.2.3.dist-info/top_level.txt,sha256=HFFDCbGu28txcGe2HPc46A7EPaguBa_b5oH7bufmxHM,10
+q3dviewer-1.2.3.dist-info/RECORD,,