q3dviewer 1.2.3__tar.gz → 1.2.5__tar.gz

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

@@ -1,10 +1,11 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.2.3
+Version: 1.2.5
 Summary: A library designed for quickly deploying a 3D viewer.
 Home-page: https://github.com/scomup/q3dviewer
 Author: Liu Yang
-License: UNKNOWN
+Author-email: liu.yang@jp.panasonic.com
+License: MIT
 Description: 
         ![q3dviewer Logo](imgs/logo.png)
         
@@ -58,22 +59,34 @@ Description:
         ```
         
         **Basic Operations**
-        * Load files: Drag and drop point cloud files onto the window (multiple files are OK).
-        * `M` key: Display the visualization settings screen for point clouds, background color, etc.
-        * `Left mouse button` & `W, A, S, D` keys: Move the viewpoint on the horizontal plane.
-        * `Z, X` keys: Move in the direction the screen is facing.
-        * `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the screen center unchanged.
-        * `Shift` + `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the camera position unchanged.
+        
+        📁 **Load Files** - Drag and drop files into the viewer
+        * Point clouds: .pcd, .ply, .las, .e57
+        * Mesh files: .stl
+        
+        📏 **Measure Distance** - Interactive point measurement
+        * `Ctrl + Left Click`: Add measurement point
+        * `Ctrl + Right Click`: Remove last point
+        * Total distance displayed automatically
+        
+        🎥 **Camera Controls** - Navigate the 3D scene
+        * `Double Click`: Set camera center to point
+        * `Right Drag`: Rotate view
+        * `Left Drag`: Pan view
+        * `Mouse Wheel`: Zoom in/out
+        
+        ⚙️ **Settings** - Press `M` to open settings window
+        * Adjust visualization properties
         
         For example, you can download and view point clouds of Tokyo in LAS format from the following link:
         
         [Tokyo Point Clouds](https://www.geospatial.jp/ckan/dataset/tokyopc-23ku-2024/resource/7807d6d1-29f3-4b36-b0c8-f7aa0ea2cff3)
         
-        ![Cloud Viewer Screenshot](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/03c981c6-1aec-e5b9-4536-e07e1e56ff29.png)
+        ![Cloud Viewer Screenshot](imgs/tokyo.png)
         
-        Press `M` on your keyboard to display a menu on the screen, where you can modify visualization settings for each item. For example, you can adjust various settings such as shape, size, color, and transparency for `CloudItem`.
+        **Mesh Support** - Starting from version 1.2.4, mesh files (.stl) are now supported.
         
-        ![Cloud Viewer Settings](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/deeb996a-e419-58f4-6bc2-535099b1b73a.png)
+        ![Screenshot from 2026-02-04 18-32-04.png](imgs/mesh.png)
         
         ### 2. ROS Viewer
         

{q3dviewer-1.2.3 → q3dviewer-1.2.5}/README.md

@@ -51,22 +51,34 @@ python3 -m q3dviewer.tools.cloud_viewer
 ```
 
 **Basic Operations**
-* Load files: Drag and drop point cloud files onto the window (multiple files are OK).
-* `M` key: Display the visualization settings screen for point clouds, background color, etc.
-* `Left mouse button` & `W, A, S, D` keys: Move the viewpoint on the horizontal plane.
-* `Z, X` keys: Move in the direction the screen is facing.
-* `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the screen center unchanged.
-* `Shift` + `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the camera position unchanged.
+
+📁 **Load Files** - Drag and drop files into the viewer
+* Point clouds: .pcd, .ply, .las, .e57
+* Mesh files: .stl
+
+📏 **Measure Distance** - Interactive point measurement
+* `Ctrl + Left Click`: Add measurement point
+* `Ctrl + Right Click`: Remove last point
+* Total distance displayed automatically
+
+🎥 **Camera Controls** - Navigate the 3D scene
+* `Double Click`: Set camera center to point
+* `Right Drag`: Rotate view
+* `Left Drag`: Pan view
+* `Mouse Wheel`: Zoom in/out
+
+⚙️ **Settings** - Press `M` to open settings window
+* Adjust visualization properties
 
 For example, you can download and view point clouds of Tokyo in LAS format from the following link:
 
 [Tokyo Point Clouds](https://www.geospatial.jp/ckan/dataset/tokyopc-23ku-2024/resource/7807d6d1-29f3-4b36-b0c8-f7aa0ea2cff3)
 
-![Cloud Viewer Screenshot](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/03c981c6-1aec-e5b9-4536-e07e1e56ff29.png)
+![Cloud Viewer Screenshot](imgs/tokyo.png)
 
-Press `M` on your keyboard to display a menu on the screen, where you can modify visualization settings for each item. For example, you can adjust various settings such as shape, size, color, and transparency for `CloudItem`.
+**Mesh Support** - Starting from version 1.2.4, mesh files (.stl) are now supported.
 
-![Cloud Viewer Settings](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/deeb996a-e419-58f4-6bc2-535099b1b73a.png)
+![Screenshot from 2026-02-04 18-32-04.png](imgs/mesh.png)
 
 ### 2. ROS Viewer
 

q3dviewer-1.2.5/q3dviewer/__init__.py

@@ -0,0 +1,5 @@
+from q3dviewer.custom_items import *
+from q3dviewer.glwidget import *
+from q3dviewer.viewer import *
+from q3dviewer.base_item import *
+from q3dviewer.base_glwidget import *

{q3dviewer-1.2.3 → q3dviewer-1.2.5}/q3dviewer/custom_items/__init__.py

@@ -8,4 +8,6 @@ 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.static_mesh_item import StaticMeshItem
 from q3dviewer.custom_items.mesh_item import MeshItem
+

{q3dviewer-1.2.3 → q3dviewer-1.2.5}/q3dviewer/custom_items/cloud_item.py

@@ -39,32 +39,34 @@ class CloudItem(BaseItem):
             - 'SPHERE': Draw each point as a sphere in 3D space.
         depth_test (bool): Whether to enable depth testing. If True, points closer to the camera will appear in front of farther ones.
     """
+    # Class-level constants
+    STRIDE = 16  # Stride of cloud array in bytes
+    CAPACITY = 10000000  # Initial buffer capacity (10M points)
+    DATA_TYPE = [('xyz', '<f4', (3,)), ('irgb', '<u4')]
+    MODE_TABLE = {'FLAT': 0, 'I': 1, 'RGB': 2, 'GRAY': 3}
+    POINT_TYPE_TABLE = {'PIXEL': 0, 'SQUARE': 1, 'SPHERE': 2}
+    
     def __init__(self, size, alpha, 
                  color_mode='I', 
                  color='white', 
                  point_type='PIXEL'):
         super().__init__()
-        self.STRIDE = 16  # stride of cloud array
         self.valid_buff_top = 0
         self.add_buff_loc = 0
         self.alpha = alpha
         self.size = size
         self.point_type = point_type
         self.mutex = threading.Lock()
-        self.data_type = [('xyz', '<f4', (3,)), ('irgb', '<u4')]
         self.color = color
         try:
             self.flat_rgb = text_to_rgba(color, flat=True)
         except ValueError:
             print(f"Invalid color: {color}, please use matplotlib color format")
             exit(1)
-        self.mode_table = {'FLAT': 0,  'I': 1,  'RGB': 2, 'GRAY': 3}
-        self.point_type_table = {'PIXEL': 0, 'SQUARE': 1, 'SPHERE': 2}
-        self.color_mode = self.mode_table[color_mode]
-        self.CAPACITY = 10000000  # 10MB * 3 (x,y,z, color) * 4
+        self.color_mode = self.MODE_TABLE[color_mode]
         self.vmin = 0
         self.vmax = 255
-        self.buff = np.empty((0), self.data_type)
+        self.buff = np.empty((0), self.DATA_TYPE)
         self.wait_add_data = None
         self.need_update_setting = True
         self.max_cloud_size = 300000000
@@ -78,7 +80,7 @@ class CloudItem(BaseItem):
         combo_ptype.addItem("pixels")
         combo_ptype.addItem("flat squares")
         combo_ptype.addItem("spheres")
-        combo_ptype.setCurrentIndex(self.point_type_table[self.point_type])
+        combo_ptype.setCurrentIndex(self.POINT_TYPE_TABLE[self.point_type])
         combo_ptype.currentIndexChanged.connect(self._on_point_type_selection)
         layout.addWidget(combo_ptype)
 
@@ -88,7 +90,7 @@ class CloudItem(BaseItem):
         self.box_size.setValue(int(self.size))
         self.box_size.setRange(0, 100)
         self.box_size.valueChanged.connect(self.set_size)
-        self._on_point_type_selection(self.point_type_table[self.point_type])
+        self._on_point_type_selection(self.POINT_TYPE_TABLE[self.point_type])
         layout.addWidget(self.box_size)
 
         box_alpha = QDoubleSpinBox()
@@ -133,11 +135,11 @@ class CloudItem(BaseItem):
         self.color_mode = index
         self.edit_rgb.hide()
         self.slider_v.hide()
-        if (index == self.mode_table['FLAT']):  # flat color
+        if (index == self.MODE_TABLE['FLAT']):  # flat color
             self.edit_rgb.show()
-        elif (index == self.mode_table['I']):  # flat color
+        elif (index == self.MODE_TABLE['I']):  # intensity
             self.slider_v.show()
-        elif (index == self.mode_table['GRAY']):  # flat color
+        elif (index == self.MODE_TABLE['GRAY']):  # grayscale
             self.slider_v.show()
 
         self.need_update_setting = True
@@ -145,15 +147,15 @@ class CloudItem(BaseItem):
     def set_color_mode(self, color_mode):
         if color_mode in {'FLAT', 'RGB', 'I', 'GRAY'}:
             try:
-                self.combo_color.setCurrentIndex(self.mode_table[color_mode])
+                self.combo_color.setCurrentIndex(self.MODE_TABLE[color_mode])
             except:
-                self.color_mode = self.mode_table[color_mode]
+                self.color_mode = self.MODE_TABLE[color_mode]
                 self.need_update_setting = True
         else:
             print(f"Invalid color mode: {color_mode}")
 
     def _on_point_type_selection(self, index):
-        self.point_type = list(self.point_type_table.keys())[index]
+        self.point_type = list(self.POINT_TYPE_TABLE.keys())[index]
         if self.point_type == 'PIXEL':
             self.box_size.setPrefix("Set size (pixel): ")
         else:
@@ -184,7 +186,7 @@ class CloudItem(BaseItem):
         self.need_update_setting = True
 
     def clear(self):
-        data = np.empty((0), self.data_type)
+        data = np.empty((0), self.DATA_TYPE)
         self.set_data(data)
 
     def set_data(self, data, append=False):
@@ -193,7 +195,7 @@ class CloudItem(BaseItem):
 
         if data.dtype in {np.dtype('float32'), np.dtype('float64')}:
             if data.size == 0:
-                data = np.empty((0), self.data_type)
+                data = np.empty((0), self.DATA_TYPE)
             elif data.ndim == 2 and data.shape[1] >= 3:
                 xyz = data[:, :3]
                 if data.shape[1] >= 4:
@@ -201,7 +203,7 @@ class CloudItem(BaseItem):
                 else:
                     color = np.zeros(data.shape[0], dtype=np.uint32)
                 data = np.rec.fromarrays(
-                    [xyz, color[:data.shape[0]]], dtype=self.data_type)
+                    [xyz, color[:data.shape[0]]], dtype=self.DATA_TYPE)
 
         with self.mutex:
             if append:
@@ -226,7 +228,7 @@ class CloudItem(BaseItem):
         set_uniform(self.program, float(self.vmin), 'vmin')
         set_uniform(self.program, float(self.alpha), 'alpha')
         set_uniform(self.program, int(self.size), 'point_size')
-        set_uniform(self.program, int(self.point_type_table[self.point_type]), 'point_type')
+        set_uniform(self.program, int(self.POINT_TYPE_TABLE[self.point_type]), 'point_type')
         glUseProgram(0)
         self.need_update_setting = False
 
@@ -245,7 +247,7 @@ class CloudItem(BaseItem):
                 buff_capacity += self.CAPACITY
             if Q3D_DEBUG is not None:
                 print("[Cloud Item] Update capacity to %d" % buff_capacity)
-            new_buff = np.empty((buff_capacity), self.data_type)
+            new_buff = np.empty((buff_capacity), self.DATA_TYPE)
             new_buff[:self.add_buff_loc] = self.buff[:self.add_buff_loc]
             new_buff[self.add_buff_loc:new_buff_top] = self.wait_add_data
             self.buff = new_buff

{q3dviewer-1.2.3 → q3dviewer-1.2.5}/q3dviewer/custom_items/mesh_item.py

@@ -17,7 +17,6 @@ from q3dviewer.utils import set_uniform, text_to_rgba
 import time
 
 
-
 class MeshItem(BaseItem):
     """
     A OpenGL mesh item for rendering 3D triangular meshes.
@@ -25,15 +24,21 @@ class MeshItem(BaseItem):
         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.
     """
+    # Class-level constants
+    FACE_CAPACITY = 1000000    # Initial capacity for faces
+    BIG_INT = 2**31 - 1         # Sentinel value for dirty region tracking
+    FACE_INPUT_DTYPE = np.dtype([
+        ('key', np.int64),
+        ('vertices', np.float32, (12,)),
+        ('good', np.uint8)
+    ])
+    
     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)
@@ -41,6 +46,12 @@ class MeshItem(BaseItem):
         # valid_f_top: pointer to end of valid faces
         self.valid_f_top = 0
         
+        # Dirty region tracking for efficient GPU updates
+        # dirty_min: start index of modified region (inclusive)
+        # dirty_max: end index of modified region (exclusive)
+        self.dirty_min = self.BIG_INT
+        self.dirty_max = 0
+        
         # key2index: mapping from face_key to face buffer index
         self.key2index = {}  # {face_key: face_index}
         
@@ -63,6 +74,7 @@ class MeshItem(BaseItem):
         
         # Settings flag
         self.need_update_setting = True
+        self.need_update_buffer = True
         self.path = os.path.dirname(__file__)
     
         
@@ -181,102 +193,151 @@ class MeshItem(BaseItem):
 
     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)]
+            data: One of the following formats:
+                  - Nx3 numpy array (N must be divisible by 3): vertex list -> static
+                  - Nx9 numpy array: triangle list -> static
+                  - Structured array with dtype [('key', int64), ('vertices', float32, (12,)), ('good', uint32)] -> incremental
         """
-        self.clear_mesh()
-
-        if isinstance(data, dict):
-            # Use dict format directly (from get_mesh_data/get_incremental_mesh_data)
+        if not isinstance(data, np.ndarray):
+            raise ValueError("Data must be a numpy array")
+        
+        # Structured array format -> use incremental path (has keys for updates)
+        if data.dtype == self.FACE_INPUT_DTYPE:
             self.set_incremental_data(data)
             return
-                
-        # Check if Nx3 array
+        
+        # Nx3 or Nx9 format -> use static path (more efficient, no key overhead)
+        if data.ndim == 2 and data.shape[1] in [3, 9]:
+            self.set_static_data(data)
+            return
+        
+        raise ValueError("Data must be Nx3, Nx9, or structured array format")
 
+    def set_static_data(self, data):
+        """
+        Efficiently set static mesh data without key2index overhead.
+        For static meshes that don't need incremental updates.
+        
+        Args:
+            data: numpy array in one of these formats:
+                  - Nx3: vertex list (N must be divisible by 3)
+                  - Nx9: triangle list
+        """
         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
+            raise ValueError("Data must be a numpy array")
+        
+        if data.ndim != 2:
+            raise ValueError(f"Data must be 2D array, got {data.ndim}D")
+        self.clear_mesh()
+        # Handle Nx3 format
+        if data.shape[1] == 3:
+            if data.shape[0] % 3 != 0:
+                raise ValueError(f"Nx3 format requires N divisible by 3, got N={data.shape[0]}")
+            
+            num_faces = data.shape[0] // 3
+            faces = np.zeros((num_faces, 13), dtype=np.float32)
+            
+            # Reshape to (num_faces, 9) for efficient copying
+            tmp = data.reshape(num_faces, 9)
+            faces[:, 0:3]  = tmp[:, 0:3]   # v0
+            faces[:, 3:6]  = tmp[:, 3:6]   # v1
+            faces[:, 6:9]  = tmp[:, 6:9]   # v2
+            faces[:, 9:12] = tmp[:, 6:9]   # v3 = v2 (degenerate)
+            faces[:, 12] = 1.0             # good=1.0
+            
+        # Handle Nx9 format
+        elif data.shape[1] == 9:
+            num_faces = data.shape[0]
+            faces = np.zeros((num_faces, 13), dtype=np.float32)
+            
+            faces[:, 0:9] = data           # Copy all 9 vertices
+            faces[:, 9:12] = data[:, 6:9]  # v3 = v2 (degenerate)
+            faces[:, 12] = 1.0             # good=1.0
+            
+        else:
+            raise ValueError(f"Data shape must be Nx3 or Nx9, got Nx{data.shape[1]}")
+        
+        # Replace faces buffer (static data, no key management)
+        self.clear_mesh()
         self.faces = faces
-        self.valid_f_top = N
+        self.valid_f_top = num_faces
+        
+        # Mark entire buffer as dirty
+        self.dirty_min = 0
+        self.dirty_max = self.valid_f_top
+        self.need_update_buffer = True
 
 
     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)
+            fs: Structured numpy array with dtype:
+                [('key', np.int64), ('vertices', np.float32, (12,)), ('good', np.uint32)]
+                - key: unique identifier for the face
+                - vertices: 12 floats representing 4 vertices (v0, v1, v2, v3)
+                - good: 0 or 1, whether to render this face
         Updates:
             - faces: updates existing faces or appends new ones
             - key2index: tracks face_key -> face_index mapping
         """
-        if not fs:
+        if fs is None or len(fs) == 0:
             return
+        
+        if not isinstance(fs, np.ndarray) or fs.dtype.names is None:
+            raise ValueError("fs must be a structured numpy array with fields: key, vertices, good")
 
         # 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)
-
+        # Prepare face data: convert structured array to Nx13 format
+        n_faces = len(fs)
+        face_data = np.zeros((n_faces, 13), dtype=np.float32)
+        
+        # Copy vertices (12 floats -> positions 0:12)
+        face_data[:, :12] = fs['vertices']
+        
+        # Copy good flag (position 12)
+        face_data[:, 12] = fs['good'].astype(np.float32)
+        
+        # Extract keys
+        keys = fs['key']
+        
+        # Optimization: Separate updates from new insertions
+        update_mask = np.array([key in self.key2index for key in keys], dtype=bool)
+        new_mask = ~update_mask
+        
         # 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
+        if np.any(update_mask):
+            update_keys = keys[update_mask]
+            update_indices = np.array([self.key2index[key] for key in update_keys], dtype=np.int32)
+            self.faces[update_indices] = face_data[update_mask]
+            
+            # Update dirty region for modified faces
+            self.dirty_min = min(self.dirty_min, int(np.min(update_indices)))
+            self.dirty_max = max(self.dirty_max, int(np.max(update_indices) + 1))
+            self.need_update_buffer = True
         
         # 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
-
+        if np.any(new_mask):
+            new_keys = keys[new_mask]
+            new_face_data = face_data[new_mask]
+            n_new = len(new_keys)
+            
+            # Update dirty region for new faces
+            start_index = self.valid_f_top            
+            # Insert data
+            self.faces[start_index: start_index + n_new] = new_face_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.key2index[face_key] = start_index + i
             self.valid_f_top += n_new
+            self.dirty_min = min(self.dirty_min, start_index)
+            self.dirty_max = max(self.dirty_max, start_index + n_new)
+            self.need_update_buffer = True
     
     def _expand_face_buffer(self):
         """Expand the faces buffer when capacity is reached"""
@@ -288,6 +349,8 @@ class MeshItem(BaseItem):
     def clear_mesh(self):
         """Clear all mesh data and reset buffers"""
         self.valid_f_top = 0
+        self.dirty_min = self.BIG_INT
+        self.dirty_max = 0
         self.key2index.clear()
         if hasattr(self, 'indices_array'):
             self.indices_array = np.array([], dtype=np.uint32)
@@ -366,13 +429,27 @@ class MeshItem(BaseItem):
             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)
+        # Upload faces to VBO (only dirty region)
+        if self.need_update_buffer:
+            glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+            
+            # Calculate the range to upload [dirty_min, dirty_max)
+            start_index = int(self.dirty_min)
+            end_index = int(self.dirty_max)
+            count = end_index - start_index
+            
+            # Upload only the modified region
+            glBufferSubData(GL_ARRAY_BUFFER,
+                           start_index * 13 * 4,  # offset in bytes
+                           count * 13 * 4,         # size in bytes
+                           self.faces[start_index:end_index])
+            
+            glBindBuffer(GL_ARRAY_BUFFER, 0)
+            self.need_update_buffer = False
+            
+            # Reset dirty region
+            self.dirty_min = self.BIG_INT
+            self.dirty_max = 0
         
     def update_setting(self):
         """Set fixed rendering parameters (called once during initialization)"""

q3dviewer-1.2.5/q3dviewer/custom_items/static_mesh_item.py

@@ -0,0 +1,330 @@
+#!/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
+
+
+class StaticMeshItem(BaseItem):
+    """
+    A OpenGL mesh item for rendering static 3D triangular meshes.
+    Optimized for static geometry with triangle-only rendering.
+    Data format: Nx9 numpy array (3 vertices per triangle, no good flag needed)
+    
+    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(StaticMeshItem, self).__init__()
+        self.wireframe = wireframe
+        self.color = color
+        self.flat_rgb = text_to_rgba(color, flat=True)
+        
+        # Static mesh buffer: N x 9 numpy array
+        # Each row: [v0.x, v0.y, v0.z, v1.x, v1.y, v1.z, v2.x, v2.y, v2.z]
+        self.vertices = None
+        self.num_triangles = 0
+        
+        # OpenGL objects
+        self.vao = None
+        self.vbo = None
+        self.program = None
+        
+        # Fixed rendering parameters
+        self.enable_lighting = True
+        self.line_width = 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.need_update_buffer = 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)
+
+        # Color setting
+        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
+            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
+            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
+            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, 100)
+            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
+            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: Nx9 numpy array where N is the number of triangles
+                  Each row: [v0.x, v0.y, v0.z, v1.x, v1.y, v1.z, v2.x, v2.y, v2.z]
+        """
+        print("Setting static mesh data with {} triangles".format(len(data)))
+        if not isinstance(data, np.ndarray):
+            raise ValueError("Data must be a numpy array")
+
+        # Check shape
+        if data.ndim != 2 or data.shape[1] != 9:
+            # Try to reshape if it's Nx3 (vertex list)
+            if data.ndim == 2 and data.shape[1] == 3 and data.shape[0] % 3 == 0:
+                data = data.reshape(-1, 9)
+            else:
+                raise ValueError(f"Invalid data shape {data.shape}. Expected Nx9 or (N*3)x3")
+
+        self.vertices = data.astype(np.float32)
+        self.num_triangles = len(self.vertices)
+        self.need_update_buffer = True
+
+    def clear_mesh(self):
+        """Clear all mesh data"""
+        self.vertices = None
+        self.num_triangles = 0
+        self.need_update_buffer = True
+
+    def initialize_gl(self):
+        """OpenGL initialization - load triangle shader"""
+        frag_shader = open(self.path + '/../shaders/mesh_frag.glsl', 'r').read()
+        
+        try:
+            vert_shader = open(self.path + '/../shaders/triangle_mesh_vert.glsl', 'r').read()
+            geom_shader = open(self.path + '/../shaders/triangle_mesh_geom.glsl', 'r').read()
+            self.program = shaders.compileProgram(
+                shaders.compileShader(vert_shader, GL_VERTEX_SHADER),
+                shaders.compileShader(geom_shader, GL_GEOMETRY_SHADER),
+                shaders.compileShader(frag_shader, GL_FRAGMENT_SHADER),
+            )
+        except Exception as e:
+            print(f"Error compiling static mesh shader: {e}")
+            raise
+
+    def update_render_buffer(self):
+        """
+        Update GPU buffer with triangle data.
+        Each triangle: 9 floats (3 vertices x 3 coordinates)
+        """
+        if self.num_triangles == 0 or self.vertices is None:
+            return
+        
+        # Initialize buffers on first call
+        if self.vao is None:
+            self.vao = glGenVertexArrays(1)
+            self.vbo = glGenBuffers(1)
+        
+        if not self.need_update_buffer:
+            return
+            
+        glBindVertexArray(self.vao)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        
+        # Upload all triangle data
+        glBufferData(GL_ARRAY_BUFFER,
+                    self.vertices.nbytes,
+                    self.vertices,
+                    GL_STATIC_DRAW)
+        
+        # Setup vertex attributes
+        # Triangle: [v0.x, v0.y, v0.z, v1.x, v1.y, v1.z, v2.x, v2.y, v2.z]
+        # 9 floats = 36 bytes stride
+        stride = 36
+        
+        # v0 (location 1) - vec3
+        glEnableVertexAttribArray(1)
+        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(0))
+        glVertexAttribDivisor(1, 1)
+        
+        # v1 (location 2) - vec3
+        glEnableVertexAttribArray(2)
+        glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(12))
+        glVertexAttribDivisor(2, 1)
+        
+        # v2 (location 3) - vec3
+        glEnableVertexAttribArray(3)
+        glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, stride, ctypes.c_void_p(24))
+        glVertexAttribDivisor(3, 1)
+        
+        glBindVertexArray(0)
+        glBindBuffer(GL_ARRAY_BUFFER, 0)
+        self.need_update_buffer = False
+        
+    def update_setting(self):
+        """Set rendering parameters"""
+        if not self.need_update_setting:
+            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, 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 static mesh using instanced rendering with geometry shader.
+        Each triangle instance is rendered as a point, geometry shader generates 1 triangle.
+        """
+        if self.num_triangles == 0 or self.vertices is None:
+            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
+        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 triangle instance)
+        # Geometry shader generates 1 triangle (3 vertices) per point
+        glDrawArraysInstanced(GL_POINTS, 0, 1, self.num_triangles)
+            
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+        glBindVertexArray(0)
+        glDisable(GL_DEPTH_TEST)
+        glDisable(GL_BLEND)
+        glUseProgram(0)

{q3dviewer-1.2.3 → q3dviewer-1.2.5}/q3dviewer/tools/cloud_viewer.py

@@ -10,6 +10,7 @@ import q3dviewer as q3d
 from q3dviewer.Qt.QtWidgets import QVBoxLayout, QDialog, QLabel
 from q3dviewer.Qt.QtCore import QThread, Signal, Qt
 from q3dviewer import GLWidget
+from q3dviewer.utils.helpers import get_version
 
 class ProgressWindow(QDialog):
     def __init__(self, parent=None):
@@ -186,7 +187,7 @@ def print_help():
     
     # Print title and table without border
     console.print()
-    console.print("[bold magenta]☁️  Cloud Viewer Help[/bold magenta]\n")
+    console.print(f"[bold magenta]☁️  Cloud Viewer ({get_version()}) Help[/bold magenta]\n")
     console.print(table)
     console.print()
 
@@ -205,7 +206,7 @@ def main():
     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
+    mesh_item = q3d.StaticMeshItem()
 
     viewer.add_items(
         {'marker': marker_item, 

{q3dviewer-1.2.3 → q3dviewer-1.2.5}/q3dviewer/tools/film_maker.py

@@ -12,7 +12,7 @@ from q3dviewer.Qt.QtCore import QTimer
 from q3dviewer.Qt.QtGui import QKeyEvent
 from q3dviewer.Qt import QtCore
 from q3dviewer import GLWidget
-from q3dviewer.tools.cloud_viewer import ProgressDialog, FileLoaderThread
+from q3dviewer.tools.cloud_viewer import FileLoaderThread, ProgressWindow
 
 import imageio.v2 as imageio
 import os
@@ -386,20 +386,19 @@ class CMMViewer(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']
@@ -417,7 +416,7 @@ def main():
     args = parser.parse_args()
     app = q3d.QApplication(['Film Maker'])
     viewer = CMMViewer(name='Film Maker', update_interval=30)
-    cloud_item = q3d.CloudIOItem(size=1, point_type='SPHERE', alpha=0.5, depth_test=True)
+    cloud_item = q3d.CloudIOItem(size=1, point_type='SPHERE', alpha=0.5)
     grid_item = q3d.GridItem(size=1000, spacing=20)
 
     viewer.add_items(

{q3dviewer-1.2.3 → q3dviewer-1.2.5}/q3dviewer/utils/helpers.py

@@ -7,6 +7,18 @@ import numpy as np
 from OpenGL.GL import *
 
 
+def get_version():
+    """
+    Get the version of q3dviewer package.
+    """
+    try:
+        from importlib.metadata import version
+        return version('q3dviewer')
+    except Exception:
+        # Fallback if package is not installed
+        return 'unknown'
+
+
 def rainbow(scalars, scalar_min=0, scalar_max=255):
     range = scalar_max - scalar_min
     values = 1.0 - (scalars - scalar_min) / range

{q3dviewer-1.2.3 → q3dviewer-1.2.5}/q3dviewer.egg-info/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.2.3
+Version: 1.2.5
 Summary: A library designed for quickly deploying a 3D viewer.
 Home-page: https://github.com/scomup/q3dviewer
 Author: Liu Yang
-License: UNKNOWN
+Author-email: liu.yang@jp.panasonic.com
+License: MIT
 Description: 
         ![q3dviewer Logo](imgs/logo.png)
         
@@ -58,22 +59,34 @@ Description:
         ```
         
         **Basic Operations**
-        * Load files: Drag and drop point cloud files onto the window (multiple files are OK).
-        * `M` key: Display the visualization settings screen for point clouds, background color, etc.
-        * `Left mouse button` & `W, A, S, D` keys: Move the viewpoint on the horizontal plane.
-        * `Z, X` keys: Move in the direction the screen is facing.
-        * `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the screen center unchanged.
-        * `Shift` + `Right mouse button` & `Arrow` keys: Rotate the viewpoint while keeping the camera position unchanged.
+        
+        📁 **Load Files** - Drag and drop files into the viewer
+        * Point clouds: .pcd, .ply, .las, .e57
+        * Mesh files: .stl
+        
+        📏 **Measure Distance** - Interactive point measurement
+        * `Ctrl + Left Click`: Add measurement point
+        * `Ctrl + Right Click`: Remove last point
+        * Total distance displayed automatically
+        
+        🎥 **Camera Controls** - Navigate the 3D scene
+        * `Double Click`: Set camera center to point
+        * `Right Drag`: Rotate view
+        * `Left Drag`: Pan view
+        * `Mouse Wheel`: Zoom in/out
+        
+        ⚙️ **Settings** - Press `M` to open settings window
+        * Adjust visualization properties
         
         For example, you can download and view point clouds of Tokyo in LAS format from the following link:
         
         [Tokyo Point Clouds](https://www.geospatial.jp/ckan/dataset/tokyopc-23ku-2024/resource/7807d6d1-29f3-4b36-b0c8-f7aa0ea2cff3)
         
-        ![Cloud Viewer Screenshot](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/03c981c6-1aec-e5b9-4536-e07e1e56ff29.png)
+        ![Cloud Viewer Screenshot](imgs/tokyo.png)
         
-        Press `M` on your keyboard to display a menu on the screen, where you can modify visualization settings for each item. For example, you can adjust various settings such as shape, size, color, and transparency for `CloudItem`.
+        **Mesh Support** - Starting from version 1.2.4, mesh files (.stl) are now supported.
         
-        ![Cloud Viewer Settings](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/149168/deeb996a-e419-58f4-6bc2-535099b1b73a.png)
+        ![Screenshot from 2026-02-04 18-32-04.png](imgs/mesh.png)
         
         ### 2. ROS Viewer
         

{q3dviewer-1.2.3 → q3dviewer-1.2.5}/q3dviewer.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ q3dviewer/custom_items/grid_item.py
 q3dviewer/custom_items/image_item.py
 q3dviewer/custom_items/line_item.py
 q3dviewer/custom_items/mesh_item.py
+q3dviewer/custom_items/static_mesh_item.py
 q3dviewer/custom_items/text3d_item.py
 q3dviewer/custom_items/text_item.py
 q3dviewer/tools/__init__.py

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

@@ -2,8 +2,10 @@ from setuptools import setup, find_packages
 
 setup(
     name='q3dviewer',
-    version='1.2.3',
+    version='1.2.5',
     author="Liu Yang",
+    author_email="liu.yang@jp.panasonic.com",
+    license="MIT",
     description="A library designed for quickly deploying a 3D viewer.",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

q3dviewer-1.2.3/q3dviewer/__init__.py

@@ -1,14 +0,0 @@
-import time
-t1 = time.time()
-from q3dviewer.custom_items import *
-t2 = time.time()
-from q3dviewer.glwidget import *
-from q3dviewer.viewer import *
-from q3dviewer.base_item import *
-from q3dviewer.base_glwidget import *
-t3 = time.time()
-
-from q3dviewer.Qt import Q3D_DEBUG
-if Q3D_DEBUG:
-    print("Import custom items: ", t2 - t1)
-    print("Import base q3dviewer: ", t3 - t2)