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

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

q3dviewer/custom_items/mesh_item.py

@@ -0,0 +1,425 @@
+#!/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, QComboBox
+import matplotlib.colors as mcolors
+import os
+from q3dviewer.utils import set_uniform, text_to_rgba
+
+
+
+class MeshItem(BaseItem):
+    """
+    An OpenGL mesh item for rendering triangulated 3D surfaces.
+
+    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)
+    """
+    def __init__(self, color='lightblue', wireframe=False, enable_lighting=True, color_mode='FLAT'):
+        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
+        self.vertex_colors = None  # Per-vertex colors (uint32 IRGB format)
+        
+        self.mode_table = {'FLAT': 0, 'I': 1, 'RGB': 2}
+        self.color_mode = self.mode_table[color_mode]
+        self.vmin = 0
+        self.vmax = 255
+        
+        # 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)
+        
+
+        # 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'")
+        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 _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
+        
+    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, colors=None):
+        """
+        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)
+        """
+        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()]
+            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)
+            
+    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 (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)
+            glEnableVertexAttribArray(2)
+            glVertexAttribIPointer(2, 1, GL_UNSIGNED_INT, 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')
+        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:
+            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,65 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aNormal;
+layout (location = 2) in uint aColor;
+
+out vec3 FragPos;
+out vec3 Normal;
+out vec3 objectColor;
+
+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;
+}
+
+void main()
+{
+    FragPos = aPos;
+    Normal = aNormal;
+    
+    vec3 c = vec3(1.0, 1.0, 1.0);
+    
+    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);
+}

q3dviewer/tools/cloud_viewer.py

@@ -49,13 +49,26 @@ 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)
+                # 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
+            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 +170,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}
@@ -176,16 +191,20 @@ def main():
     viewer = CloudViewer(name='Cloud Viewer')
     cloud_item = q3d.CloudIOItem(size=1, alpha=0.1)
     axis_item = q3d.AxisItem(size=0.5, width=5)
+    axis_item.disable_setting()
     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)
+    text_item.disable_setting()
+    mesh_item = q3d.MeshItem()  # Added MeshIOItem for mesh support
 
     viewer.add_items(
         {'marker': marker_item, 
-         'cloud': cloud_item, 
+         'cloud': cloud_item,
+         'mesh': mesh_item,
          'grid': grid_item, 
          'axis': axis_item, 
-         'text': text_item})
+         'text': text_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-1.2.0.dist-info → q3dviewer-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.2.0
+Version: 1.2.2
 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.2.0.dist-info → q3dviewer-1.2.2.dist-info}/RECORD

@@ -4,15 +4,16 @@ 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=McZmTKFllQn0ZiVJDzJJnpcZ-jpgzfO3tLPp03rop7E,13520
+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=Ds3GyYzvFF5VpjG-_LU9SNZiBoLmztCZrkcalEMjub8,17890
 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=tj9pbaWUYoKn1CtYahahPVzXNDTEtaQanq3S3VphmPg,1896
 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=sZ16uOt5J_3E7H0ZW3NHq0mTkWuoBkRRtwEQgcEv-Io,7794
 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=Cs_xrwt6FCDVxGxan7r-ARd5ySwQ50xnCzcmz0dB_X0,4215
-q3dviewer-1.2.0.dist-info/LICENSE,sha256=81cMOyNfw8KLb1JnPYngGHJ5W83gSbZEBU9MEP3tl-E,1124
-q3dviewer-1.2.0.dist-info/METADATA,sha256=RFXc1PDLrmk1xqidvKx4RoU0_aBfK1aYyQK_TZs3bp0,8024
-q3dviewer-1.2.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-q3dviewer-1.2.0.dist-info/entry_points.txt,sha256=EOjker7XYaBk70ffvNB_knPcfA33Bnlg21ZjEeM1EyI,362
-q3dviewer-1.2.0.dist-info/top_level.txt,sha256=HFFDCbGu28txcGe2HPc46A7EPaguBa_b5oH7bufmxHM,10
-q3dviewer-1.2.0.dist-info/RECORD,,
+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,,