q3dviewer 1.2.4__tar.gz → 1.2.5__tar.gz

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

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

{q3dviewer-1.2.4 → 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.4 → q3dviewer-1.2.5}/q3dviewer/custom_items/mesh_item.py

@@ -24,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)
@@ -40,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}
         
@@ -190,14 +202,8 @@ class MeshItem(BaseItem):
         if not isinstance(data, np.ndarray):
             raise ValueError("Data must be a numpy array")
         
-        want_dtype = np.dtype([
-            ('key', np.int64),
-            ('vertices', np.float32, (12,)),
-            ('good', np.uint32)
-        ])
-        
         # Structured array format -> use incremental path (has keys for updates)
-        if data.dtype == want_dtype:
+        if data.dtype == self.FACE_INPUT_DTYPE:
             self.set_incremental_data(data)
             return
         
@@ -256,6 +262,10 @@ class MeshItem(BaseItem):
         self.clear_mesh()
         self.faces = faces
         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
 
 
@@ -304,6 +314,11 @@ class MeshItem(BaseItem):
             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 np.any(new_mask):
@@ -311,13 +326,17 @@ class MeshItem(BaseItem):
             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[self.valid_f_top: self.valid_f_top + n_new] = new_face_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):
@@ -330,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)
@@ -408,16 +429,27 @@ class MeshItem(BaseItem):
             glBindBuffer(GL_ARRAY_BUFFER, 0)
             self._gpu_face_capacity = len(self.faces)
         
-        # Upload faces to VBO
+        # 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,
-                           0,
-                           self.valid_f_top * 13 * 4,  # 13 floats * 4 bytes per face
-                           self.faces[:self.valid_f_top])
+                           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
-            glBindBuffer(GL_ARRAY_BUFFER, 0)
+            
+            # 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.4 → q3dviewer-1.2.5}/q3dviewer.egg-info/PKG-INFO

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

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

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='q3dviewer',
-    version='1.2.4',
+    version='1.2.5',
     author="Liu Yang",
     author_email="liu.yang@jp.panasonic.com",
     license="MIT",