q3dviewer 1.2.1__tar.gz → 1.2.3__tar.gz

{q3dviewer-1.2.1 → q3dviewer-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.2.1
+Version: 1.2.3
 Summary: A library designed for quickly deploying a 3D viewer.
 Home-page: https://github.com/scomup/q3dviewer
 Author: Liu Yang

q3dviewer-1.2.3/q3dviewer/custom_items/mesh_item.py

@@ -0,0 +1,442 @@
+#!/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 os
+from q3dviewer.utils import set_uniform, text_to_rgba
+import time
+
+
+
+class MeshItem(BaseItem):
+    """
+    A OpenGL mesh item for rendering 3D triangular meshes.
+    Attributes:
+        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):
+        super(MeshItem, self).__init__()
+        self.wireframe = wireframe
+        self.color = color
+        self.flat_rgb = text_to_rgba(color, flat=True)
+        
+        # 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
+        
+        # key2index: mapping from face_key to face buffer index
+        self.key2index = {}  # {face_key: face_index}
+        
+        # OpenGL objects
+        self.vao = None
+        self.vbo = None
+        self.program = None
+        self._gpu_face_capacity = 0    # Track GPU buffer capacity
+        
+        # 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]
+        self.ambient_strength = 0.1
+        self.diffuse_strength = 1.2
+        self.specular_strength = 0.1
+        self.shininess = 32.0
+        self.alpha = 1.0
+        
+        # Settings flag
+        self.need_update_setting = True
+        self.path = os.path.dirname(__file__)
+    
+        
+    def add_setting(self, layout):
+        """Add UI controls for mesh visualization"""
+        # 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)
+
+        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, 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):
+        """
+        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
+        """
+        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:
+                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"""
+        # 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):
+        """
+        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
+        
+        # Initialize buffers on first call
+        if self.vao is None:
+            self.vao = glGenVertexArrays(1)
+            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, 52, ctypes.c_void_p(0))
+            glVertexAttribDivisor(1, 1)
+            
+            # v1 (location 2) - vec3
+            glEnableVertexAttribArray(2)
+            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):
+        """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, 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')
+        self.need_update_setting = False
+
+    def paint(self):
+        """
+        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
+        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 (vertex positions are now in VBO attributes)
+        glBindVertexArray(self.vao)
+                
+        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)
+        glUseProgram(0)
+        

{q3dviewer-1.2.1 → q3dviewer-1.2.3}/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-1.2.1 → q3dviewer-1.2.3}/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,20 +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)
-                mesh_item.set_data(verts=verts, faces=faces)
+                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()
 
 
@@ -130,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']
@@ -154,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()
@@ -186,18 +200,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,
-         'mesh': mesh_item})
+         'text': text_item,})
 
     if args.path:
         pcd_fn = args.path

{q3dviewer-1.2.1 → q3dviewer-1.2.3}/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.1 → q3dviewer-1.2.3}/q3dviewer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.2.1
+Version: 1.2.3
 Summary: A library designed for quickly deploying a 3D viewer.
 Home-page: https://github.com/scomup/q3dviewer
 Author: Liu Yang

{q3dviewer-1.2.1 → q3dviewer-1.2.3}/q3dviewer.egg-info/requires.txt

@@ -5,7 +5,6 @@ laspy
 matplotlib
 meshio
 numpy
-numpy-stl
 pye57
 pypcd4
 pyside6

{q3dviewer-1.2.1 → q3dviewer-1.2.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='q3dviewer',
-    version='1.2.1',
+    version='1.2.3',
     author="Liu Yang",
     description="A library designed for quickly deploying a 3D viewer.",
     long_description=open("README.md").read(),
@@ -29,7 +29,6 @@ setup(
         'imageio',
         'imageio[ffmpeg]',
         'matplotlib',
-        'numpy-stl',
     ],
     entry_points={
         'console_scripts': [

q3dviewer-1.2.1/q3dviewer/custom_items/mesh_item.py

@@ -1,342 +0,0 @@
-#!/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)
-