q3dviewer 1.1.9__py3-none-any.whl → 1.2.1__py3-none-any.whl

q3dviewer/base_glwidget.py

@@ -399,8 +399,6 @@ class BaseGLWidget(QOpenGLWidget):
                     points.append((x0 + dx, y0 + dy))
         points = sorted(points, key=lambda p: (p[0]-x0)**2 + (p[1]-y0)**2)
 
-        print("points to check:", len(points))
-
         gl_y0 = height - y0 - 1
         z = 1.0
         for x, y in points:
@@ -411,7 +409,6 @@ class BaseGLWidget(QOpenGLWidget):
             z = glReadPixels(x, gl_y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT)
             z = np.frombuffer(z, dtype=np.float32)[0]
             if z != 1.0 and z != 0.0:
-                print("dist to  p:", np.sqrt((x - x0)**2 + (y - y0)**2))
                 break
 
         if z == 1.0 or z == 0.0:

q3dviewer/custom_items/__init__.py

@@ -8,3 +8,4 @@ from q3dviewer.custom_items.text_item import Text2DItem
 from q3dviewer.custom_items.image_item import ImageItem
 from q3dviewer.custom_items.line_item import LineItem
 from q3dviewer.custom_items.text3d_item import Text3DItem
+from q3dviewer.custom_items.mesh_item import MeshItem

q3dviewer/custom_items/cloud_item.py

@@ -42,8 +42,7 @@ class CloudItem(BaseItem):
     def __init__(self, size, alpha, 
                  color_mode='I', 
                  color='white', 
-                 point_type='PIXEL', 
-                 depth_test=False):
+                 point_type='PIXEL'):
         super().__init__()
         self.STRIDE = 16  # stride of cloud array
         self.valid_buff_top = 0
@@ -70,7 +69,6 @@ class CloudItem(BaseItem):
         self.need_update_setting = True
         self.max_cloud_size = 300000000
         # Enable depth test when full opaque
-        self.depth_test = depth_test
         self.path = os.path.dirname(__file__)
 
     def add_setting(self, layout):
@@ -126,13 +124,6 @@ class CloudItem(BaseItem):
         self.slider_v.rangeChanged.connect(self._on_range)
         layout.addWidget(self.slider_v)
 
-        self.checkbox_depth_test = QCheckBox(
-            "Show front points first (Depth Test)")
-        self.checkbox_depth_test.setChecked(self.depth_test)
-        self.checkbox_depth_test.stateChanged.connect(self.set_depthtest)
-        self._on_color_mode(self.color_mode)
-        layout.addWidget(self.checkbox_depth_test)
-
     def _on_range(self, lower, upper):
         self.vmin = lower
         self.vmax = upper
@@ -192,9 +183,6 @@ class CloudItem(BaseItem):
         self.size = size
         self.need_update_setting = True
 
-    def set_depthtest(self, state):
-        self.depth_test = state
-
     def clear(self):
         data = np.empty((0), self.data_type)
         self.set_data(data)
@@ -304,15 +292,16 @@ class CloudItem(BaseItem):
     def paint(self):
         self.update_render_buffer()
         self.update_setting()
+        
         glEnable(GL_BLEND)
         glEnable(GL_PROGRAM_POINT_SIZE)
         glEnable(GL_POINT_SPRITE)
         glEnable(GL_DEPTH_TEST)
         
-        if not self.depth_test:
-            glDepthFunc(GL_ALWAYS)  # Always pass depth test but still write depth
+        if self.alpha < 0.9:
+            glDepthFunc(GL_ALWAYS)
         else:
-            glDepthFunc(GL_LESS)    # Normal depth testing
+            glDepthFunc(GL_LESS)
 
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
         glUseProgram(self.program)

q3dviewer/custom_items/mesh_item.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+
+"""
+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 *
+from OpenGL.GL import shaders
+from q3dviewer.Qt.QtWidgets import QLabel, QCheckBox, QDoubleSpinBox, QSlider, QHBoxLayout, QLineEdit
+import matplotlib.colors as mcolors
+import os
+from q3dviewer.utils import set_uniform, text_to_rgba
+
+
+
+class MeshItem(BaseItem):
+    def __init__(self, color='lightblue', wireframe=False, enable_lighting=True):
+        super(MeshItem, self).__init__()
+        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
+        
+        # OpenGL objects
+        self.vao = None
+        self.vbo_vertices = None
+        self.vbo_normals = None
+        # self.vbo_colors = None
+        self.program = None
+        
+        # Rendering parameters
+        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
+        self.need_update_setting = True
+        self.path = os.path.dirname(__file__)
+    
+        
+    def add_setting(self, layout):
+        """Add UI controls for mesh visualization"""
+        # Wireframe toggle
+        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)
+        
+
+        label_rgb = QLabel("Color:")
+        label_rgb.setToolTip("Use hex color, i.e. #FF4500, or named color, i.e. 'red'")
+        layout.addWidget(label_rgb)
+        self.edit_rgb = QLineEdit()
+        self.edit_rgb.setToolTip("Use hex color, i.e. #FF4500, or named color, i.e. 'red'")
+        self.edit_rgb.setText(self.color)
+        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)
+            ambient_layout = QHBoxLayout()
+            ambient_label = QLabel("Ambient Strength:")
+            ambient_layout.addWidget(ambient_label)
+            self.ambient_slider = QSlider()
+            self.ambient_slider.setOrientation(1)  # Qt.Horizontal
+            self.ambient_slider.setRange(0, 100)
+            self.ambient_slider.setValue(int(self.ambient_strength * 100))
+            self.ambient_slider.valueChanged.connect(lambda v: self.update_ambient_strength(v / 100.0))
+            ambient_layout.addWidget(self.ambient_slider)
+            layout.addLayout(ambient_layout)
+
+            # Diffuse strength control (slider 0-200 mapped to 0.0-2.0)
+            diffuse_layout = QHBoxLayout()
+            diffuse_label = QLabel("Diffuse Strength:")
+            diffuse_layout.addWidget(diffuse_label)
+            self.diffuse_slider = QSlider()
+            self.diffuse_slider.setOrientation(1)
+            self.diffuse_slider.setRange(0, 200)
+            self.diffuse_slider.setValue(int(self.diffuse_strength * 100))
+            self.diffuse_slider.valueChanged.connect(lambda v: self.update_diffuse_strength(v / 100.0))
+            diffuse_layout.addWidget(self.diffuse_slider)
+            layout.addLayout(diffuse_layout)
+
+            # Specular strength control (slider 0-200 mapped to 0.0-2.0)
+            specular_layout = QHBoxLayout()
+            specular_label = QLabel("Specular Strength:")
+            specular_layout.addWidget(specular_label)
+            self.specular_slider = QSlider()
+            self.specular_slider.setOrientation(1)
+            self.specular_slider.setRange(0, 200)
+            self.specular_slider.setValue(int(self.specular_strength * 100))
+            self.specular_slider.valueChanged.connect(lambda v: self.update_specular_strength(v / 100.0))
+            specular_layout.addWidget(self.specular_slider)
+            layout.addLayout(specular_layout)
+
+            # Shininess control (slider 1-256 mapped to 1-256)
+            shininess_layout = QHBoxLayout()
+            shininess_label = QLabel("Shininess:")
+            shininess_layout.addWidget(shininess_label)
+            self.shininess_slider = QSlider()
+            self.shininess_slider.setOrientation(1)
+            self.shininess_slider.setRange(1, 256)
+            self.shininess_slider.setValue(int(self.shininess))
+            self.shininess_slider.valueChanged.connect(lambda v: self.update_shininess(float(v)))
+            shininess_layout.addWidget(self.shininess_slider)
+            layout.addLayout(shininess_layout)
+
+    def _on_color(self, color):
+        try:
+            self.color = color
+            self.flat_rgb = text_to_rgba(color, flat=True)
+            self.need_update_setting = True
+        except ValueError:
+            pass
+
+
+    def update_wireframe(self, value):
+        self.wireframe = value
+        
+    def update_enable_lighting(self, value):
+        self.enable_lighting = value
+        self.need_update_setting = True
+        
+    def update_line_width(self, value):
+        self.line_width = value
+        self.need_update_setting = True
+        
+    def update_ambient_strength(self, value):
+        self.ambient_strength = value
+        self.need_update_setting = True
+        
+    def update_diffuse_strength(self, value):
+        self.diffuse_strength = value
+        self.need_update_setting = True
+        
+    def update_specular_strength(self, value):
+        self.specular_strength = value
+        self.need_update_setting = True
+        
+    def update_shininess(self, value):
+        self.shininess = value
+        self.need_update_setting = True
+
+    def update_alpha(self, value):
+        """Update mesh alpha (opacity)"""
+        self.alpha = float(value)
+        self.need_update_setting = True
+            
+    def set_data(self, verts, faces):
+        """
+        verts: np.ndarray of shape (N, 3)
+        faces: np.ndarray of shape (M, 3) with uint32 indices
+        """
+        verts = np.asarray(verts, dtype=np.float32)
+        faces = np.asarray(faces, dtype=np.uint32)
+        triangles = verts[faces.flatten()]
+            
+        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)
+            
+    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
+
+    def update_render_buffer(self):
+        """Initialize OpenGL buffers"""
+        if not self.need_update_buffer:
+            return
+            
+        # Generate VAO and VBOs
+        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)
+            glEnableVertexAttribArray(1)
+            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, None)
+        
+        # Color buffer
+        # if self.flat_rgbs is not None:
+        #     glBindBuffer(GL_ARRAY_BUFFER, self.vbo_colors)
+        #     glBufferData(GL_ARRAY_BUFFER, self.flat_rgbs.nbytes, self.flat_rgbs, GL_STATIC_DRAW)
+        #     glEnableVertexAttribArray(2)
+        #     glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 0, None)
+        # 
+        glBindVertexArray(0)
+        self.need_update_buffer = False
+        
+    def update_setting(self):
+        if (self.need_update_setting is False):
+            return
+        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, 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')
+        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:
+            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
+        set_uniform(self.program, project_matrix, 'projection')
+        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
+        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))
+            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+                
+        glBindVertexArray(0)
+        glDisable(GL_DEPTH_TEST)
+        glDisable(GL_BLEND)
+        glUseProgram(0)
+        

q3dviewer/shaders/mesh_frag.glsl

@@ -0,0 +1,66 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec3 FragPos;
+in vec3 Normal;  
+in vec3 objectColor;
+
+const vec3 LIGHT_DIR = normalize(vec3(1.0, 1.0, 1.0));
+// Lighting uniforms
+uniform bool if_light;
+uniform bool two_sided;
+// directional light - use a global constant direction (world space)
+uniform vec3 light_color;
+uniform vec3 view_pos;
+
+// Material properties
+uniform float ambient_strength;
+uniform float diffuse_strength;
+uniform float specular_strength;
+uniform float shininess;
+// Opacity
+uniform float alpha;
+
+void main()
+{
+    if (if_light)
+    {
+        // Ambient lighting
+        vec3 ambient = ambient_strength * light_color;
+        
+        // Diffuse lighting with optional two-sided support
+        vec3 norm = normalize(Normal);
+        vec3 lightDir = LIGHT_DIR; // global directional light
+        float diff;
+        if (two_sided) {
+            // Two-sided lighting - both front and back faces receive light
+            diff = max(abs(dot(norm, lightDir)), 0.0);
+        } else {
+            // Standard one-sided lighting
+            diff = max(dot(norm, lightDir), 0.0);
+        }
+        vec3 diffuse = diffuse_strength * diff * light_color;
+        
+        // Specular lighting (Phong reflection model) with optional two-sided support
+    vec3 viewDir = normalize(view_pos - FragPos);
+    vec3 reflectDir = reflect(-lightDir, norm);
+        float spec;
+        if (two_sided) {
+            // Two-sided specular
+            spec = pow(max(abs(dot(viewDir, reflectDir)), 0.0), shininess);
+        } else {
+            // Standard one-sided specular
+            spec = pow(max(dot(viewDir, reflectDir), 0.0), shininess);
+        }
+        vec3 specular = specular_strength * spec * light_color;
+        
+        // Combine all lighting components
+        vec3 result = (ambient + diffuse + specular) * objectColor;
+        FragColor = vec4(result, alpha);
+    }
+    else
+    {
+        // No lighting - just object color
+        FragColor = vec4(objectColor, alpha);
+    }
+}

q3dviewer/shaders/mesh_vert.glsl

@@ -0,0 +1,29 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aNormal;
+layout (location = 2) in float aColor;
+
+out vec3 FragPos;
+out vec3 Normal;
+out vec3 objectColor;
+
+uniform mat4 view;
+uniform mat4 projection;
+uniform int flat_rgb;
+
+void main()
+{
+    FragPos = aPos;
+    
+    Normal = aNormal;
+    
+    int color_int = int(aColor);
+    objectColor = vec3(
+        float((uint(flat_rgb) & uint(0x00FF0000)) >> 16)/255.,
+        float((uint(flat_rgb) & uint(0x0000FF00)) >> 8)/255.,
+        float( uint(flat_rgb) & uint(0x000000FF))/255.
+    ) ;
+    
+    // Final vertex position (apply view/projection)
+    gl_Position = projection * view * vec4(aPos, 1.0);
+}

q3dviewer/tools/cloud_viewer.py

@@ -49,13 +49,21 @@ class FileLoaderThread(QThread):
 
     def run(self):
         cloud_item = self.viewer['cloud']
+        mesh_item = self.viewer['mesh']
         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)
-            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))
+            if url.toLocalFile().lower().endswith(('.stl')):
+                from q3dviewer.utils.cloud_io import load_stl
+                verts, faces = load_stl(file_path)
+                mesh_item.set_data(verts=verts, faces=faces)
+            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()
 
 
@@ -157,6 +165,8 @@ def print_help():
     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}
@@ -179,13 +189,15 @@ def main():
     grid_item = q3d.GridItem(size=1000, spacing=20)
     marker_item = q3d.Text3DItem()  # Changed from CloudItem to Text3DItem
     text_item = q3d.Text2DItem(pos=(20, 40), text="", color='lime', size=16)
+    mesh_item = q3d.MeshItem()  # Added MeshIOItem for mesh support
 
     viewer.add_items(
         {'marker': marker_item, 
          'cloud': cloud_item, 
          'grid': grid_item, 
          'axis': axis_item, 
-         'text': text_item})
+         'text': text_item,
+         'mesh': mesh_item})
 
     if args.path:
         pcd_fn = args.path

q3dviewer/utils/cloud_io.py

@@ -6,6 +6,27 @@ Distributed under MIT license. See LICENSE for more information.
 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)
+
+
 def save_ply(cloud, save_path):
     import meshio
     xyz = cloud['xyz']

q3dviewer/utils/range_slider.py

@@ -37,19 +37,21 @@ class RangeSlider(QSlider):
             self.active_handle = "upper"
 
     def mouseMoveEvent(self, event):
-        """Override to update handle positions."""
+        """Override to update handle positions, always clamp and int for cross-platform safety."""
         if event.buttons() != Qt.LeftButton:
             return
 
         pos = self.pixelPosToValue(event.pos())
+        minv, maxv = self.minimum(), self.maximum()
         if self.active_handle == "lower":
-            self.lower_value = max(
-                self.minimum(), min(pos, self.upper_value - 1))
+            self.lower_value = max(minv, min(pos, self.upper_value - 1))
+            self.lower_value = int(round(self.lower_value))
             QToolTip.showText(event.globalPos(), f"Lower: {self.lower_value:.1f}")
         elif self.active_handle == "upper":
-            self.upper_value = min(
-                self.maximum(), max(pos, self.lower_value + 1))
+            self.upper_value = min(maxv, max(pos, self.lower_value + 1))
+            self.upper_value = int(round(self.upper_value))
             QToolTip.showText(event.globalPos(), f"Upper: {self.upper_value:.1f}")
+        # Always emit clamped, int values
         self.rangeChanged.emit(self.lower_value, self.upper_value)
         self.update()
 

{q3dviewer-1.1.9.dist-info → q3dviewer-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.1.9
+Version: 1.2.1
 Summary: A library designed for quickly deploying a 3D viewer.
 Home-page: https://github.com/scomup/q3dviewer
 Author: Liu Yang
@@ -17,6 +17,7 @@ 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.1.9.dist-info → q3dviewer-1.2.1.dist-info}/RECORD

@@ -1,18 +1,19 @@
 q3dviewer/__init__.py,sha256=cjyfUE5zK6xohDGDQIWfb0DKkWChVznBd7CrVLg7whQ,376
-q3dviewer/base_glwidget.py,sha256=iBvYqoFAqh09TDzugqDfu99_JqHL6IrvWOjm1XJJpsk,15395
+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/viewer.py,sha256=Vq3ucDlBcBBoiVVGmqG1sRjhLePl50heblx6wJpsc1A,2603
 q3dviewer/Qt/__init__.py,sha256=VJj7Ge6N_81__T9eHFl_YQpa1HyQrlLhMqC_9pUOYtc,2233
-q3dviewer/custom_items/__init__.py,sha256=cwcNn40MzYXVO9eSzpRknJdzZNKPf2kaEMZy5DCNYcE,567
+q3dviewer/custom_items/__init__.py,sha256=kaaf84wOObfybJ8a12FqPMeg8ImTJWggA6g5nvpY2YY,621
 q3dviewer/custom_items/axis_item.py,sha256=-WM2urosqV847zpTpOtxdLjb7y9NJqFCH13qqodcCTg,2572
 q3dviewer/custom_items/cloud_io_item.py,sha256=Haz-SOUUCPDSHgmKyyyFfP7LXBSEiN4r8xmchQwCm-k,4721
-q3dviewer/custom_items/cloud_item.py,sha256=NkZ5rFM_hVxBPMZYml3oX2CI5d0ApJY1wet8I1eIssE,14024
+q3dviewer/custom_items/cloud_item.py,sha256=UzpkWiMYcX8kEndmRV1ScysFfOvElaKo60KV-uEO2A4,13484
 q3dviewer/custom_items/frame_item.py,sha256=bUzww3tSDah0JZeqtU6_cYHhhTVWzXhJVMcAa5pCXHI,7458
 q3dviewer/custom_items/gaussian_item.py,sha256=JMubpahkTPh0E8ShL3FLTahv0e35ODzjgK5K1i0YXSU,9884
 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=LfiF6A6XTbMVyaP5E6GpgiR-wPjwxNLXKdWEOzYs-TU,13342
 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
@@ -20,9 +21,11 @@ q3dviewer/shaders/cloud_vert.glsl,sha256=gKI6EJrzX5ga2W2yjU6x7Wjz7Cu2Y-wrPl4g10R
 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=oF96vp2Et_ueY5slBtyuuJp4ZPJGoKKE-9xu0vlFORc,683
 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=UsKALGiFR2Ck___LSGNPIZ3PPUlECO20jVkcP5g6yyc,6807
+q3dviewer/tools/cloud_viewer.py,sha256=ZDdyHDPump8BKOwK-8yxgJ8cuVfGrcSOEkyaLR-Kk4o,7431
 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
@@ -30,15 +33,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=xarfYakY0zgKwvZkgKSPO6b4DEo42hsq3mcvCbK64yg,12134
+q3dviewer/utils/cloud_io.py,sha256=vU03lT4Y-4oPPTNV137HBw-tfwwCwpcaoz3ENWfIAN4,12837
 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=9djTxuzmzH54DgSwAljRpLGjsrIJ0hTxhaxFjPxsk8g,4007
-q3dviewer-1.1.9.dist-info/LICENSE,sha256=81cMOyNfw8KLb1JnPYngGHJ5W83gSbZEBU9MEP3tl-E,1124
-q3dviewer-1.1.9.dist-info/METADATA,sha256=k7pCVA3O73KUcjQEWcO08VM0Vl50gcBopuYVlyu1nU4,8024
-q3dviewer-1.1.9.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-q3dviewer-1.1.9.dist-info/entry_points.txt,sha256=EOjker7XYaBk70ffvNB_knPcfA33Bnlg21ZjEeM1EyI,362
-q3dviewer-1.1.9.dist-info/top_level.txt,sha256=HFFDCbGu28txcGe2HPc46A7EPaguBa_b5oH7bufmxHM,10
-q3dviewer-1.1.9.dist-info/RECORD,,
+q3dviewer/utils/range_slider.py,sha256=Cs_xrwt6FCDVxGxan7r-ARd5ySwQ50xnCzcmz0dB_X0,4215
+q3dviewer-1.2.1.dist-info/LICENSE,sha256=81cMOyNfw8KLb1JnPYngGHJ5W83gSbZEBU9MEP3tl-E,1124
+q3dviewer-1.2.1.dist-info/METADATA,sha256=BOYtmAeK-XjasJ_GTJcnJ6q3N2XJQnsfvqeHhm4P8kI,8049
+q3dviewer-1.2.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+q3dviewer-1.2.1.dist-info/entry_points.txt,sha256=EOjker7XYaBk70ffvNB_knPcfA33Bnlg21ZjEeM1EyI,362
+q3dviewer-1.2.1.dist-info/top_level.txt,sha256=HFFDCbGu28txcGe2HPc46A7EPaguBa_b5oH7bufmxHM,10
+q3dviewer-1.2.1.dist-info/RECORD,,