q3dviewer 1.2.1__tar.gz → 1.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.2.1
+Version: 1.2.2
 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.2}/q3dviewer/custom_items/mesh_item.py

@@ -10,7 +10,7 @@ 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
+from q3dviewer.Qt.QtWidgets import QLabel, QCheckBox, QDoubleSpinBox, QSlider, QHBoxLayout, QLineEdit, QComboBox
 import matplotlib.colors as mcolors
 import os
 from q3dviewer.utils import set_uniform, text_to_rgba
@@ -18,7 +18,53 @@ from q3dviewer.utils import set_uniform, text_to_rgba
 
 
 class MeshItem(BaseItem):
-    def __init__(self, color='lightblue', wireframe=False, enable_lighting=True):
+    """
+    An OpenGL mesh item for rendering triangulated 3D surfaces.
+
+    Attributes:
+        color (str or tuple): The flat color to use when `color_mode` is 'FLAT'. 
+            Accepts any valid matplotlib color (e.g., 'lightblue', 'red', '#FF4500', (1.0, 0.5, 0.0)).
+        wireframe (bool): If True, render the mesh in wireframe mode (edges only). 
+            If False, render filled triangles. Default is False.
+        enable_lighting (bool): Whether to enable Phong lighting for the mesh. 
+            If True, the mesh will be shaded based on light direction and material properties.
+            If False, the mesh will use flat shading with object colors only. Default is True.
+        color_mode (str): The coloring mode for mesh vertices.
+            - 'FLAT': Single flat color for all vertices (uses the `color` attribute).
+            - 'I': Color by intensity channel from per-vertex colors (rainbow gradient).
+            - 'RGB': Per-vertex RGB color from per-vertex color data.
+        alpha (float): The transparency of the mesh, in the range [0, 1], 
+            where 0 is fully transparent and 1 is fully opaque. Default is 1.0.
+        line_width (float): The width of lines when rendering in wireframe mode. 
+            Range is typically 0.5 to 5.0. Default is 1.0.
+        
+    Material Properties (Phong Lighting):
+        ambient_strength (float): Ambient light contribution [0.0-1.0]. Default is 0.1.
+        diffuse_strength (float): Diffuse light contribution [0.0-2.0]. Default is 1.2.
+        specular_strength (float): Specular highlight contribution [0.0-2.0]. Default is 0.1.
+        shininess (float): Specular shininess exponent [1-256]. Higher values = smaller highlights. Default is 32.0.
+        
+    Methods:
+        set_data(verts, faces, colors=None): Set mesh geometry and optional per-vertex colors.
+            - verts: np.ndarray of shape (N, 3) - vertex positions
+            - faces: np.ndarray of shape (M, 3) with uint32 indices - triangle indices
+            - colors: np.ndarray of shape (N,) with uint32 IRGB format (optional)
+                     uint32 format: I (bits 24-31), R (bits 16-23), G (bits 8-15), B (bits 0-7)
+                     
+    Example:
+        # Create a simple triangle mesh with per-vertex colors
+        verts = np.array([[0,0,0], [1,0,0], [0,1,0]], dtype=np.float32)
+        faces = np.array([[0,1,2]], dtype=np.uint32)
+        colors = np.array([
+            (255 << 24) | (255 << 16) | (0 << 8) | 0,  # Red, intensity=255
+            (200 << 24) | (0 << 16) | (255 << 8) | 0,  # Green, intensity=200
+            (150 << 24) | (0 << 16) | (0 << 8) | 255   # Blue, intensity=150
+        ], dtype=np.uint32)
+        
+        mesh = q3d.MeshItem(color='lightblue', color_mode='RGB', enable_lighting=True)
+        mesh.set_data(verts, faces, colors)
+    """
+    def __init__(self, color='lightblue', wireframe=False, enable_lighting=True, color_mode='FLAT'):
         super(MeshItem, self).__init__()
         self.color = color
         self.flat_rgb = text_to_rgba(color, flat=True)
@@ -28,12 +74,18 @@ class MeshItem(BaseItem):
         # Mesh data
         self.triangles = None
         self.normals = None
+        self.vertex_colors = None  # Per-vertex colors (uint32 IRGB format)
+        
+        self.mode_table = {'FLAT': 0, 'I': 1, 'RGB': 2}
+        self.color_mode = self.mode_table[color_mode]
+        self.vmin = 0
+        self.vmax = 255
         
         # OpenGL objects
         self.vao = None
         self.vbo_vertices = None
         self.vbo_normals = None
-        # self.vbo_colors = None
+        self.vbo_colors = None
         self.program = None
         
         # Rendering parameters
@@ -90,6 +142,17 @@ class MeshItem(BaseItem):
         layout.addWidget(alpha_box)
         
 
+        # Color mode selection
+        label_color = QLabel("Color Mode:")
+        layout.addWidget(label_color)
+        self.combo_color = QComboBox()
+        self.combo_color.addItem("flat color")
+        self.combo_color.addItem("intensity")
+        self.combo_color.addItem("RGB")
+        self.combo_color.setCurrentIndex(self.color_mode)
+        self.combo_color.currentIndexChanged.connect(self._on_color_mode)
+        layout.addWidget(self.combo_color)
+
         label_rgb = QLabel("Color:")
         label_rgb.setToolTip("Use hex color, i.e. #FF4500, or named color, i.e. 'red'")
         layout.addWidget(label_rgb)
@@ -158,6 +221,11 @@ class MeshItem(BaseItem):
         except ValueError:
             pass
 
+    def _on_color_mode(self, index):
+        print(f"Color mode1 : {index}")
+        self.color_mode = index
+        self.edit_rgb.setVisible(index == self.mode_table['FLAT'])
+        self.need_update_setting = True
 
     def update_wireframe(self, value):
         self.wireframe = value
@@ -191,14 +259,26 @@ class MeshItem(BaseItem):
         self.alpha = float(value)
         self.need_update_setting = True
             
-    def set_data(self, verts, faces):
+    def set_data(self, verts, faces, colors=None):
         """
         verts: np.ndarray of shape (N, 3)
         faces: np.ndarray of shape (M, 3) with uint32 indices
+        colors: np.ndarray of shape (N,) with uint32 IRGB format (optional)
+                uint32 contains: I (bits 24-31), R (bits 16-23), G (bits 8-15), B (bits 0-7)
         """
         verts = np.asarray(verts, dtype=np.float32)
         faces = np.asarray(faces, dtype=np.uint32)
         triangles = verts[faces.flatten()]
+
+        if colors is not None:
+            colors = np.asarray(colors, dtype=np.uint32)
+            if len(colors) == len(verts):
+                # Expand per-vertex colors to per-triangle-vertex
+                self.vertex_colors = colors[faces.flatten()]
+            else:
+                self.vertex_colors = None
+        else:
+            self.vertex_colors = None
             
         self.triangles = np.asarray(triangles, dtype=np.float32)
         self.normals = self.calculate_normals()
@@ -256,7 +336,7 @@ class MeshItem(BaseItem):
             self.vao = glGenVertexArrays(1)
             self.vbo_vertices = glGenBuffers(1)
             self.vbo_normals = glGenBuffers(1)
-            # self.vbo_colors = glGenBuffers(1)
+            self.vbo_colors = glGenBuffers(1)
         
         glBindVertexArray(self.vao)
         
@@ -273,13 +353,13 @@ class MeshItem(BaseItem):
             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)
-        # 
+        # Color buffer (uint32 IRGB format)
+        if self.vertex_colors is not None:
+            glBindBuffer(GL_ARRAY_BUFFER, self.vbo_colors)
+            glBufferData(GL_ARRAY_BUFFER, self.vertex_colors.nbytes, self.vertex_colors, GL_STATIC_DRAW)
+            glEnableVertexAttribArray(2)
+            glVertexAttribIPointer(2, 1, GL_UNSIGNED_INT, 0, None)
+        
         glBindVertexArray(0)
         self.need_update_buffer = False
         
@@ -295,6 +375,9 @@ class MeshItem(BaseItem):
         set_uniform(self.program, float(self.shininess), 'shininess')
         set_uniform(self.program, float(self.alpha), 'alpha')
         set_uniform(self.program, int(self.flat_rgb), 'flat_rgb')
+        set_uniform(self.program, int(self.color_mode), 'color_mode')
+        set_uniform(self.program, float(self.vmin), 'vmin')
+        set_uniform(self.program, float(self.vmax), 'vmax')
         self.need_update_setting = False
 
     def paint(self):

{q3dviewer-1.2.1 → q3dviewer-1.2.2}/q3dviewer/tools/cloud_viewer.py

@@ -58,7 +58,12 @@ class FileLoaderThread(QThread):
             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)
+                # create colors, N, array
+                color = np.zeros((verts.shape[0],), dtype=np.uint32)
+                # random uint32 colors in IRGB format
+                color = np.random.randint(0, 0xFFFFFFFF, size=(verts.shape[0],), dtype=np.uint32)
+                mesh_item.set_data(verts=verts, faces=faces, colors=color)
+                break
             else:
                 cloud = cloud_item.load(file_path, append=(i > 0))
                 center = np.nanmean(cloud['xyz'].astype(np.float64), axis=0)
@@ -186,18 +191,20 @@ def main():
     viewer = CloudViewer(name='Cloud Viewer')
     cloud_item = q3d.CloudIOItem(size=1, alpha=0.1)
     axis_item = q3d.AxisItem(size=0.5, width=5)
+    axis_item.disable_setting()
     grid_item = q3d.GridItem(size=1000, spacing=20)
     marker_item = q3d.Text3DItem()  # Changed from CloudItem to Text3DItem
     text_item = q3d.Text2DItem(pos=(20, 40), text="", color='lime', size=16)
+    text_item.disable_setting()
     mesh_item = q3d.MeshItem()  # Added MeshIOItem for mesh support
 
     viewer.add_items(
         {'marker': marker_item, 
-         'cloud': cloud_item, 
+         'cloud': cloud_item,
+         'mesh': mesh_item,
          'grid': grid_item, 
          'axis': axis_item, 
-         'text': text_item,
-         'mesh': mesh_item})
+         'text': text_item,})
 
     if args.path:
         pcd_fn = args.path

{q3dviewer-1.2.1 → q3dviewer-1.2.2}/q3dviewer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: q3dviewer
-Version: 1.2.1
+Version: 1.2.2
 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.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='q3dviewer',
-    version='1.2.1',
+    version='1.2.2',
     author="Liu Yang",
     description="A library designed for quickly deploying a 3D viewer.",
     long_description=open("README.md").read(),