import os import json import tempfile import logging import struct import time from typing import List, Any, Dict, Tuple import numpy as np import torch # 导入ComfyUI的路径管理 try: import folder_paths FOLDER_PATHS_AVAILABLE = True except ImportError: folder_paths = None FOLDER_PATHS_AVAILABLE = False # 导入trimesh用于GLB文件处理 try: import trimesh TRIMESH_AVAILABLE = True except ImportError: TRIMESH_AVAILABLE = False trimesh = None # 配置日志 logger = logging.getLogger('glb_point_cloud_processor') class GLBPointCloudProcessor: """GLB点云文件处理器 - 专门用于删除黑色点和暗色点优化""" @classmethod def INPUT_TYPES(cls): return { "required": { "glb_file_path": ("STRING", { "default": "", "tooltip": "GLB点云文件路径：输入需要处理的GLB格式点云文件路径。支持绝对路径(如C:/path/to/file.glb)或相对于ComfyUI output目录的相对路径(如pointcloud.glb)。GLB文件应包含点云数据，支持带颜色信息的点云处理" }), }, "optional": { "black_threshold": ("INT", { "default": 30, "min": 0, "max": 255, "step": 1, "tooltip": "黑色阈值控制：RGB三色总和小于此值的点将被删除。0=仅删除纯黑点(0,0,0)；30=删除深黑色点；60=删除较暗点；100=删除中等暗度点；255=删除所有点。调大=删除更多暗色点，点云更亮净；调小=保留更多暗色细节，但可能有噪点" }), "output_filename": ("STRING", { "default": "clean_pointcloud", "tooltip": "输出GLB文件名：处理后点云的保存文件名，系统会自动添加.glb扩展名。文件将保存到ComfyUI的output目录中。建议使用描述性名称如'clean_pointcloud'、'filtered_scan'等便于识别" }), } } RETURN_TYPES = ( "STRING", # 处理后的GLB文件路径 ) RETURN_NAMES = ( "processed_glb_path", ) OUTPUT_TOOLTIPS = [ "处理后的GLB文件完整路径", ] OUTPUT_NODE = True FUNCTION = "process_point_cloud" CATEGORY = "💃VVL/Point Cloud Cleaning" def process_point_cloud(self, glb_file_path: str, black_threshold: int = 30, output_filename: str = "clean_pointcloud"): """ 处理GLB点云文件，删除黑色点和暗色点 """ processing_log = [] processing_log.append("开始GLB点云黑色点清理...") # 检查依赖 if not TRIMESH_AVAILABLE: error_msg = "trimesh库不可用，无法处理GLB文件" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("",) # 验证输入文件路径 if not glb_file_path or not glb_file_path.strip(): error_msg = "GLB文件路径为空" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("",) # 处理文件路径 input_path = self._resolve_file_path(glb_file_path.strip()) processing_log.append(f"输入文件路径: {input_path}") if not os.path.exists(input_path): error_msg = f"GLB文件不存在: {input_path}" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("",) try: # 加载GLB文件 processing_log.append("正在加载GLB文件...") scene = trimesh.load(input_path) # 提取点云数据 point_clouds = [] other_geometries = [] if isinstance(scene, trimesh.Scene): for name, geometry in scene.geometry.items(): if isinstance(geometry, trimesh.PointCloud): point_clouds.append((name, geometry)) processing_log.append(f"发现点云: {name}, 点数: {len(geometry.vertices)}") else: other_geometries.append((name, geometry)) processing_log.append(f"发现其他几何体: {name}, 类型: {type(geometry).__name__}") elif isinstance(scene, trimesh.PointCloud): point_clouds.append(("main_pointcloud", scene)) processing_log.append(f"发现点云: main_pointcloud, 点数: {len(scene.vertices)}") else: # 尝试转换为点云 if hasattr(scene, 'vertices'): pc = trimesh.PointCloud(vertices=scene.vertices, colors=getattr(scene.visual, 'vertex_colors', None)) point_clouds.append(("converted_pointcloud", pc)) processing_log.append(f"转换为点云: converted_pointcloud, 点数: {len(pc.vertices)}") else: error_msg = "GLB文件中未找到点云数据" processing_log.append(f"错误: {error_msg}") return ("",) if not point_clouds: error_msg = "GLB文件中没有点云数据" processing_log.append(f"错误: {error_msg}") return ("",) # 处理每个点云 processed_point_clouds = [] total_original_points = 0 total_removed_points = 0 for name, point_cloud in point_clouds: processing_log.append(f"\n处理点云: {name}") original_count = len(point_cloud.vertices) total_original_points += original_count # 获取原始点云的所有属性和状态 original_vertices = point_cloud.vertices.copy() colors = None # 获取颜色信息 if hasattr(point_cloud.visual, 'vertex_colors') and point_cloud.visual.vertex_colors is not None: colors = point_cloud.visual.vertex_colors.copy() elif hasattr(point_cloud, 'colors') and point_cloud.colors is not None: colors = point_cloud.colors.copy() # 初始化掩码（所有点都保留） keep_mask = np.ones(len(original_vertices), dtype=bool) # 删除暗色点（仅基于颜色，不改变顶点坐标） if colors is not None: removed_count = self._remove_dark_points(original_vertices, colors, keep_mask, black_threshold, processing_log) processing_log.append(f"删除黑色点: {removed_count} 个") else: processing_log.append("跳过黑色点过滤: 点云无颜色信息") # 应用掩码，保留原始的顶点坐标 filtered_vertices = original_vertices[keep_mask] filtered_colors = colors[keep_mask] if colors is not None else None remaining_count = len(filtered_vertices) removed_count = original_count - remaining_count total_removed_points += removed_count processing_log.append(f"点云 {name}: 原始 {original_count} -> 剩余 {remaining_count} (删除 {removed_count})") # 创建处理后的点云，保留所有原始属性 if remaining_count > 0: # 使用原始点云作为模板，只更新顶点和颜色 processed_pc = point_cloud.copy() processed_pc.vertices = filtered_vertices if filtered_colors is not None: processed_pc.visual.vertex_colors = filtered_colors processed_point_clouds.append((name, processed_pc)) processing_log.append(f"保留点云 {name} 的所有原始属性和状态") else: processing_log.append(f"警告: 点云 {name} 处理后没有剩余点") # 直接修改原始场景，保持所有几何信息不变 if processed_point_clouds: # 使用原始场景作为基础，直接替换点云数据 new_scene = scene # 直接修改原始场景中的点云几何体，保持变换不变 for name, processed_pc in processed_point_clouds: if isinstance(scene, trimesh.Scene): # 获取原始几何体 if name in scene.geometry: original_geometry = scene.geometry[name] # 如果是点云，直接修改顶点和颜色 if isinstance(original_geometry, trimesh.PointCloud): original_geometry.vertices = processed_pc.vertices if hasattr(processed_pc.visual, 'vertex_colors') and processed_pc.visual.vertex_colors is not None: original_geometry.visual.vertex_colors = processed_pc.visual.vertex_colors processing_log.append(f"直接修改原始点云 {name}，保持所有变换和属性不变") else: # 如果不是点云类型，替换整个几何体但保持变换 scene.delete_geometry(name) scene.add_geometry(processed_pc, node_name=name) processing_log.append(f"替换几何体 {name}，尝试保持变换") else: # 新增几何体 scene.add_geometry(processed_pc, node_name=name) processing_log.append(f"添加新点云 {name}") else: # 单个几何体的情况 new_scene = processed_pc processing_log.append("单个几何体，直接使用处理后的点云") processing_log.append("直接修改原始场景，所有变换矩阵和几何属性完全保持不变") # 生成输出路径 output_path = self._generate_output_path(output_filename) processing_log.append(f"输出文件路径: {output_path}") # 保存处理后的GLB文件 processing_log.append("正在保存处理后的GLB文件...") new_scene.export(output_path) # 验证文件是否保存成功 if os.path.exists(output_path): file_size = os.path.getsize(output_path) processing_log.append(f"GLB文件保存成功，文件大小: {file_size} bytes") # 验证输出文件的一致性 try: # 加载输出文件进行验证 verification_scene = trimesh.load(output_path) processing_log.append("文件验证: 输出文件可正常加载") # 检查是否保留了场景结构 if isinstance(scene, trimesh.Scene) and isinstance(verification_scene, trimesh.Scene): processing_log.append(f"场景结构验证: 原始 {len(scene.geometry)} 个对象 -> 输出 {len(verification_scene.geometry)} 个对象") except Exception as e: processing_log.append(f"文件验证警告: {str(e)}") processing_log.append("GLB点云黑色点清理完成! 已保留原始模型的大小、朝向和几何属性") return (output_path,) else: error_msg = "GLB文件保存失败" processing_log.append(f"错误: {error_msg}") return ("",) else: error_msg = "处理后没有剩余的点云数据" processing_log.append(f"错误: {error_msg}") return ("",) except Exception as e: error_msg = f"处理GLB文件时发生错误: {str(e)}" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") import traceback traceback.print_exc() return ("",) def _resolve_file_path(self, file_path: str) -> str: """解析文件路径，支持绝对路径和相对路径""" if os.path.isabs(file_path): return file_path # 尝试相对于ComfyUI输出目录 if FOLDER_PATHS_AVAILABLE: output_dir = folder_paths.get_output_directory() candidate_path = os.path.join(output_dir, file_path) if os.path.exists(candidate_path): return candidate_path # 尝试相对于当前工作目录 if os.path.exists(file_path): return os.path.abspath(file_path) # 返回原始路径（让后续检查处理错误） return file_path def _generate_output_path(self, filename: str) -> str: """生成输出文件路径""" if FOLDER_PATHS_AVAILABLE: output_dir = folder_paths.get_output_directory() else: output_dir = "output" # 确保输出目录存在 os.makedirs(output_dir, exist_ok=True) # 处理文件名，确保是.glb扩展名 if not filename.lower().endswith('.glb'): filename = f"{filename}.glb" return os.path.join(output_dir, filename) def _remove_dark_points(self, vertices: np.ndarray, colors: np.ndarray, keep_mask: np.ndarray, black_threshold: int, processing_log: List[str]) -> int: """删除暗色点""" removed_count = 0 # 确保颜色数据格式正确 if colors.shape[1] == 4: # RGBA rgb_colors = colors[:, :3] else: # RGB rgb_colors = colors # 如果颜色值在0-1范围内，转换为0-255 if rgb_colors.max() <= 1.0: rgb_colors = (rgb_colors * 255).astype(np.uint8) else: rgb_colors = rgb_colors.astype(np.uint8) # 计算RGB总和 rgb_sum = rgb_colors.sum(axis=1) # 应用黑色阈值过滤 if black_threshold > 0: dark_mask = rgb_sum >= black_threshold before_count = keep_mask.sum() keep_mask &= dark_mask after_count = keep_mask.sum() removed_by_black = before_count - after_count removed_count += removed_by_black processing_log.append(f" 按RGB总和阈值({black_threshold})删除: {removed_by_black} 个点") return removed_count class GLBPointCloudBounds: """GLB点云包围盒计算器 - 计算包围盒并生成带可视化的预览文件（原模型数据保持不变）""" @classmethod def INPUT_TYPES(cls): return { "required": { "glb_file_path": ("STRING", { "default": "", "tooltip": "GLB点云文件路径：输入需要计算包围盒的GLB格式点云文件。支持绝对路径或相对于ComfyUI output目录的相对路径。注意：此节点在原模型基础上添加预览信息，原模型数据保持不变" }), }, "optional": { "bounding_box_type": (["axis_aligned", "oriented"], { "default": "axis_aligned", "tooltip": "包围盒类型：axis_aligned=轴对齐包围盒(AABB)，计算快速；oriented=有向包围盒(OBB)，体积最小" }), "units": (["meters", "centimeters", "millimeters"], { "default": "meters", "tooltip": "输出单位：指定包围盒尺寸的输出单位" }), "add_bounding_box_visualization": ("BOOLEAN", { "default": True, "tooltip": "添加包围盒可视化：是否在输出的点云文件中添加红色包围盒线框点云，便于直接预览验证" }), "add_coordinate_axes": ("BOOLEAN", { "default": False, "tooltip": "添加坐标轴：是否添加RGB坐标轴(X=红色，Y=绿色，Z=蓝色)到输出点云中" }), "wireframe_density": ("INT", { "default": 150, "min": 20, "max": 200, "step": 10, "tooltip": "线框密度：每条包围盒边的点数，越高线框越清晰但点数越多。推荐50-100获得清晰效果" }), "enhance_visibility": ("BOOLEAN", { "default": True, "tooltip": "增强可见性：添加顶点高亮和面中心标记，让包围盒更容易识别" }), "output_filename": ("STRING", { "default": "pointcloud_with_bounds", "tooltip": "输出文件名：带包围盒可视化的点云文件名，系统会自动添加.glb扩展名" }), } } RETURN_TYPES = ( "STRING", # 输出的GLB文件路径 "STRING", # JSON格式的scale数组 ) RETURN_NAMES = ( "output_glb_path", "scale_json", ) OUTPUT_TOOLTIPS = [ "带预览的GLB文件路径 - 包含原始点云+包围盒可视化+坐标轴的完整点云文件", "纯净的scale数组JSON: {\"scale\": [长, 宽, 高]} - 仅包含scale信息，可直接用于3D引擎缩放", ] OUTPUT_NODE = True FUNCTION = "calculate_bounds_and_visualize" CATEGORY = "💃VVL/Point Cloud Analysis" def calculate_bounds_and_visualize(self, glb_file_path: str, bounding_box_type: str = "axis_aligned", units: str = "meters", add_bounding_box_visualization: bool = True, add_coordinate_axes: bool = True, wireframe_density: int = 50, enhance_visibility: bool = True, output_filename: str = "pointcloud_with_bounds"): """ 计算GLB点云文件的包围盒尺寸并生成带可视化的点云文件 """ processing_log = [] processing_log.append("开始GLB点云包围盒计算和可视化生成...") # 检查依赖 if not TRIMESH_AVAILABLE: error_msg = "trimesh库不可用，无法处理GLB文件" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("", "") # 验证输入文件路径 if not glb_file_path or not glb_file_path.strip(): error_msg = "GLB文件路径为空" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("", "") # 处理文件路径 input_path = self._resolve_file_path(glb_file_path.strip()) self._current_input_path = input_path # 保存当前输入路径供后续使用 processing_log.append(f"输入文件路径: {input_path}") if not os.path.exists(input_path): error_msg = f"GLB文件不存在: {input_path}" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("", "") try: # 加载GLB文件 processing_log.append("正在加载GLB文件...") scene = trimesh.load(input_path) # 收集所有点云数据，考虑变换矩阵 all_vertices = [] point_cloud_count = 0 if isinstance(scene, trimesh.Scene): for node_name in scene.graph.nodes: if node_name in scene.geometry: geometry = scene.geometry[node_name] transform_matrix = scene.graph[node_name][0] # 获取变换矩阵 if hasattr(geometry, 'vertices') and geometry.vertices is not None: # 应用变换矩阵获取真实世界坐标 if transform_matrix is not None and not np.allclose(transform_matrix, np.eye(4)): world_vertices = trimesh.transformations.transform_points(geometry.vertices, transform_matrix) processing_log.append(f"发现几何体: {node_name}, 点数: {len(geometry.vertices)}, 已应用变换矩阵") else: world_vertices = geometry.vertices.copy() processing_log.append(f"发现几何体: {node_name}, 点数: {len(geometry.vertices)}, 无变换") all_vertices.append(world_vertices) point_cloud_count += 1 elif isinstance(scene, trimesh.PointCloud): all_vertices.append(scene.vertices) point_cloud_count = 1 processing_log.append(f"发现点云: main_pointcloud, 点数: {len(scene.vertices)}") elif hasattr(scene, 'vertices') and scene.vertices is not None: all_vertices.append(scene.vertices) point_cloud_count = 1 processing_log.append(f"发现几何体(作为点云处理): main_geometry, 点数: {len(scene.vertices)}") else: error_msg = "GLB文件中未找到点云或几何体数据" processing_log.append(f"错误: {error_msg}") return ("", "") if not all_vertices: error_msg = "GLB文件中没有可用的顶点数据" processing_log.append(f"错误: {error_msg}") return ("", "") # 合并所有顶点（已经是世界坐标） combined_vertices = np.vstack(all_vertices) total_points = len(combined_vertices) processing_log.append(f"合并了 {point_cloud_count} 个几何体，总点数: {total_points} (已应用变换矩阵)") # 计算包围盒 processing_log.append(f"计算包围盒类型: {bounding_box_type}") if bounding_box_type == "axis_aligned": # 轴对齐包围盒 (AABB) min_point = np.min(combined_vertices, axis=0) max_point = np.max(combined_vertices, axis=0) extents = max_point - min_point center = (min_point + max_point) / 2 processing_log.append(f"AABB计算完成:") processing_log.append(f" 最小点: [{min_point[0]:.6f}, {min_point[1]:.6f}, {min_point[2]:.6f}]") processing_log.append(f" 最大点: [{max_point[0]:.6f}, {max_point[1]:.6f}, {max_point[2]:.6f}]") processing_log.append(f" 中心点: [{center[0]:.6f}, {center[1]:.6f}, {center[2]:.6f}]") processing_log.append(f" 尺寸: [{extents[0]:.6f}, {extents[1]:.6f}, {extents[2]:.6f}]") processing_log.append(f" 体积: {np.prod(extents):.6f}") else: # oriented # 有向包围盒 (OBB) try: to_origin, obb_extents = trimesh.bounds.oriented_bounds(combined_vertices) # 计算OBB的中心点 obb_center = -to_origin[:3, 3] # 变换矩阵的平移部分的负值 center = obb_center # 设置center变量 extents = obb_extents processing_log.append(f"OBB计算完成:") processing_log.append(f" 中心点: [{center[0]:.6f}, {center[1]:.6f}, {center[2]:.6f}]") processing_log.append(f" 尺寸: [{extents[0]:.6f}, {extents[1]:.6f}, {extents[2]:.6f}]") processing_log.append(f" 体积: {np.prod(extents):.6f}") except Exception as e: processing_log.append(f"OBB计算失败，回退到AABB: {str(e)}") # 回退到AABB min_point = np.min(combined_vertices, axis=0) max_point = np.max(combined_vertices, axis=0) extents = max_point - min_point center = (min_point + max_point) / 2 # 应用单位转换 unit_scale = {"meters": 1.0, "centimeters": 100.0, "millimeters": 1000.0} scale_factor = unit_scale.get(units, 1.0) scaled_extents = extents * scale_factor # 生成scale JSON (按照 [长, 宽, 高] 的顺序，通常是 [X, Y, Z]) scale_array = [float(scaled_extents[0]), float(scaled_extents[1]), float(scaled_extents[2])] scale_json = { "name": output_filename, "scale": scale_array } processing_log.append(f"") processing_log.append(f"输出结果 (单位: {units}):") processing_log.append(f" Scale数组: [{scale_array[0]:.6f}, {scale_array[1]:.6f}, {scale_array[2]:.6f}]") processing_log.append(f" 长度(X): {scale_array[0]:.6f} {units}") processing_log.append(f" 宽度(Y): {scale_array[1]:.6f} {units}") processing_log.append(f" 高度(Z): {scale_array[2]:.6f} {units}") # 生成带可视化的点云文件（原模型数据不变，仅添加预览） output_glb_path = "" try: processing_log.append("正在生成带包围盒可视化的点云文件...") output_glb_path = self._generate_visualization_pointcloud( combined_vertices, extents, center, bounding_box_type, add_bounding_box_visualization, add_coordinate_axes, wireframe_density, enhance_visibility, output_filename, processing_log ) processing_log.append("可视化点云文件生成完成!") except Exception as e: processing_log.append(f"可视化点云生成失败: {str(e)}") import traceback traceback.print_exc() processing_log.append("GLB点云包围盒计算和可视化完成!") return ( output_glb_path, json.dumps(scale_json, indent=2), ) except Exception as e: error_msg = f"计算包围盒时发生错误: {str(e)}" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") import traceback traceback.print_exc() return ("", "") def _resolve_file_path(self, file_path: str) -> str: """解析文件路径，支持绝对路径和相对路径""" if os.path.isabs(file_path): return file_path # 尝试相对于ComfyUI输出目录 if FOLDER_PATHS_AVAILABLE: output_dir = folder_paths.get_output_directory() candidate_path = os.path.join(output_dir, file_path) if os.path.exists(candidate_path): return candidate_path # 尝试相对于当前工作目录 if os.path.exists(file_path): return os.path.abspath(file_path) # 返回原始路径（让后续检查处理错误） return file_path def _get_current_input_path(self): """获取当前输入文件路径""" return getattr(self, '_current_input_path', None) def _normalize_colors(self, colors): """标准化颜色数组为RGBA格式，0-255范围""" if colors is None: return None colors = np.array(colors) # 如果是0-1范围，转换为0-255 if colors.max() <= 1.0: colors = (colors * 255).astype(np.uint8) else: colors = colors.astype(np.uint8) # 确保是RGBA格式 if colors.shape[1] == 3: # RGB -> RGBA alpha_channel = np.full((colors.shape[0], 1), 255, dtype=np.uint8) colors = np.hstack([colors, alpha_channel]) elif colors.shape[1] != 4: # 如果不是3或4通道，创建白色RGBA colors = np.tile([255, 255, 255, 255], (colors.shape[0], 1)).astype(np.uint8) return colors def _generate_visualization_pointcloud(self, combined_vertices, extents, center, bounds_type, add_bounding_box_visualization, add_coordinate_axes, wireframe_density, enhance_visibility, output_filename, processing_log): """生成包含原始点云、包围盒线框和坐标轴的可视化点云文件""" try: # 直接使用已加载的原始场景数据，避免重新加载可能改变朝向 input_path = self._get_current_input_path() # 提取原始点云数据（完全保持原始状态） all_vertices = [] all_colors = [] original_point_count = 0 # 使用之前已经加载的combined_vertices作为基础，重新从原始场景提取完整数据 original_scene = trimesh.load(input_path) # 创建一个新的场景，完全保持原始场景的结构和变换 visualization_scene = trimesh.Scene() # 保持原始场景的完整结构 if isinstance(original_scene, trimesh.Scene): # 完全复制原始场景的所有几何体和变换 for node_name in original_scene.graph.nodes: if node_name in original_scene.geometry: geometry = original_scene.geometry[node_name] transform_matrix = original_scene.graph[node_name][0] # 获取变换矩阵 # 完全复制几何体，保持所有属性 copied_geometry = geometry.copy() # 添加到新场景，保持原始的变换矩阵 visualization_scene.add_geometry(copied_geometry, node_name=node_name, transform=transform_matrix) # 提取顶点用于统计（注意：这里用于显示统计，真实包围盒计算已在前面完成） if hasattr(geometry, 'vertices') and geometry.vertices is not None: # 这里不需要再次应用变换，因为包围盒计算已经在combined_vertices中处理过了 all_vertices.append(geometry.vertices) # 保持原始颜色 if isinstance(geometry, trimesh.PointCloud): if hasattr(geometry.visual, 'vertex_colors') and geometry.visual.vertex_colors is not None: colors = geometry.visual.vertex_colors.copy() elif hasattr(geometry, 'colors') and geometry.colors is not None: colors = geometry.colors.copy() else: colors = np.tile([255, 255, 255, 255], (len(geometry.vertices), 1)) else: if hasattr(geometry.visual, 'vertex_colors') and geometry.visual.vertex_colors is not None: colors = geometry.visual.vertex_colors.copy() else: colors = np.tile([200, 200, 200, 255], (len(geometry.vertices), 1)) # 确保颜色格式一致 (RGBA, 0-255) colors = self._normalize_colors(colors) all_colors.append(colors) original_point_count += len(geometry.vertices) processing_log.append(f"完全保持原始几何体: {node_name}, 变换矩阵和所有属性已保留") elif isinstance(original_scene, trimesh.PointCloud): # 单个点云，直接复制 visualization_scene = original_scene.copy() all_vertices.append(original_scene.vertices) if hasattr(original_scene.visual, 'vertex_colors') and original_scene.visual.vertex_colors is not None: colors = original_scene.visual.vertex_colors.copy() elif hasattr(original_scene, 'colors') and original_scene.colors is not None: colors = original_scene.colors.copy() else: colors = np.tile([255, 255, 255, 255], (len(original_scene.vertices), 1)) colors = self._normalize_colors(colors) all_colors.append(colors) original_point_count = len(original_scene.vertices) processing_log.append(f"完全保持原始点云: {original_point_count:,} 个点") else: # 单个几何体，转换为场景保持结构 visualization_scene.add_geometry(original_scene.copy(), node_name="main_geometry") if hasattr(original_scene, 'vertices') and original_scene.vertices is not None: all_vertices.append(original_scene.vertices) if hasattr(original_scene.visual, 'vertex_colors') and original_scene.visual.vertex_colors is not None: colors = original_scene.visual.vertex_colors.copy() else: colors = np.tile([200, 200, 200, 255], (len(original_scene.vertices), 1)) colors = self._normalize_colors(colors) all_colors.append(colors) original_point_count = len(original_scene.vertices) processing_log.append(f"完全保持原始几何体: {original_point_count:,} 个点") processing_log.append(f"原始模型结构完全保留: {original_point_count:,} 个点，所有变换矩阵和朝向不变") # 添加包围盒线框点云到场景 if add_bounding_box_visualization: box_vertices, box_colors = self._create_bounding_box_pointcloud( extents, center, bounds_type, wireframe_density, enhance_visibility, processing_log ) if len(box_vertices) > 0: # 创建包围盒点云并添加到场景 bounding_box_pointcloud = trimesh.PointCloud(vertices=box_vertices, colors=box_colors) visualization_scene.add_geometry(bounding_box_pointcloud, node_name="bounding_box_visualization") processing_log.append(f"包围盒线框: {len(box_vertices):,} 个点") # 添加坐标轴点云到场景 if add_coordinate_axes: axes_vertices, axes_colors = self._create_coordinate_axes_pointcloud( extents, center, wireframe_density, processing_log ) if len(axes_vertices) > 0: # 创建坐标轴点云并添加到场景 coordinate_axes_pointcloud = trimesh.PointCloud(vertices=axes_vertices, colors=axes_colors) visualization_scene.add_geometry(coordinate_axes_pointcloud, node_name="coordinate_axes") processing_log.append(f"坐标轴: {len(axes_vertices):,} 个点") # 统计总点数 total_visualization_points = original_point_count box_point_count = 0 axes_point_count = 0 if add_bounding_box_visualization: box_point_count = len(box_vertices) if 'box_vertices' in locals() and len(box_vertices) > 0 else 0 total_visualization_points += box_point_count if add_coordinate_axes: axes_point_count = len(axes_vertices) if 'axes_vertices' in locals() and len(axes_vertices) > 0 else 0 total_visualization_points += axes_point_count processing_log.append(f"总点数: {total_visualization_points:,} 个点") # 生成输出路径 output_path = self._generate_output_path(output_filename) # 保存场景，完全保持原始模型的结构和朝向 visualization_scene.export(output_path) processing_log.append(f"可视化点云已保存: {output_path}") return output_path except Exception as e: processing_log.append(f"可视化点云生成失败: {str(e)}") raise e def _create_bounding_box_pointcloud(self, extents, center, bounds_type, wireframe_density, enhance_visibility, processing_log): """创建包围盒线框的点云表示""" try: # 计算包围盒的8个顶点 min_point = center - extents/2 max_point = center + extents/2 box_vertices = np.array([ [min_point[0], min_point[1], min_point[2]], # 0: min corner [max_point[0], min_point[1], min_point[2]], # 1 [max_point[0], max_point[1], min_point[2]], # 2 [min_point[0], max_point[1], min_point[2]], # 3 [min_point[0], min_point[1], max_point[2]], # 4 [max_point[0], min_point[1], max_point[2]], # 5 [max_point[0], max_point[1], max_point[2]], # 6: max corner [min_point[0], max_point[1], max_point[2]], # 7 ]) # 定义包围盒的12条边 edges = [ (0, 1), (1, 2), (2, 3), (3, 0), # 底面 (4, 5), (5, 6), (6, 7), (7, 4), # 顶面 (0, 4), (1, 5), (2, 6), (3, 7), # 垂直边 ] wireframe_points = [] # 1. 生成线框边上的点（更密集） for start_idx, end_idx in edges: start_point = box_vertices[start_idx] end_point = box_vertices[end_idx] # 在每条边上生成密集的点 for i in range(wireframe_density): t = i / (wireframe_density - 1) if wireframe_density > 1 else 0 point = start_point + t * (end_point - start_point) wireframe_points.append(point) # 2. 添加顶点高亮和面中心标记（可选增强可见性） if enhance_visibility: # 顶点高亮（每个顶点周围添加小点云） vertex_highlight_radius = np.min(extents) * 0.01 # 顶点高亮半径 highlight_density = max(5, wireframe_density // 10) # 顶点周围的点数 for vertex in box_vertices: # 在每个顶点周围创建小的点云球 for i in range(highlight_density): # 生成随机方向 theta = np.random.uniform(0, 2 * np.pi) phi = np.random.uniform(0, np.pi) r = np.random.uniform(0, vertex_highlight_radius) # 球坐标转换为笛卡尔坐标 x = vertex[0] + r * np.sin(phi) * np.cos(theta) y = vertex[1] + r * np.sin(phi) * np.sin(theta) z = vertex[2] + r * np.cos(phi) wireframe_points.append([x, y, z]) # 面中心点标记 face_centers = [ # 底面中心 (box_vertices[0] + box_vertices[1] + box_vertices[2] + box_vertices[3]) / 4, # 顶面中心 (box_vertices[4] + box_vertices[5] + box_vertices[6] + box_vertices[7]) / 4, # 前面中心 (box_vertices[0] + box_vertices[1] + box_vertices[4] + box_vertices[5]) / 4, # 后面中心 (box_vertices[2] + box_vertices[3] + box_vertices[6] + box_vertices[7]) / 4, # 左面中心 (box_vertices[0] + box_vertices[3] + box_vertices[4] + box_vertices[7]) / 4, # 右面中心 (box_vertices[1] + box_vertices[2] + box_vertices[5] + box_vertices[6]) / 4, ] # 在每个面中心添加标记点 face_mark_density = max(3, wireframe_density // 20) face_mark_radius = np.min(extents) * 0.005 for face_center in face_centers: for i in range(face_mark_density): # 在面中心周围添加小的点云 theta = np.random.uniform(0, 2 * np.pi) phi = np.random.uniform(0, np.pi) r = np.random.uniform(0, face_mark_radius) x = face_center[0] + r * np.sin(phi) * np.cos(theta) y = face_center[1] + r * np.sin(phi) * np.sin(theta) z = face_center[2] + r * np.cos(phi) wireframe_points.append([x, y, z]) wireframe_vertices = np.array(wireframe_points) # 为包围盒线框设置红色 wireframe_colors = np.tile([255, 0, 0, 255], (len(wireframe_vertices), 1)) processing_log.append(f"包围盒线框生成: {len(wireframe_vertices):,} 个点 (密度={wireframe_density})") return wireframe_vertices, wireframe_colors except Exception as e: processing_log.append(f"创建包围盒点云失败: {str(e)}") return np.array([]), np.array([]) def _create_coordinate_axes_pointcloud(self, extents, origin_center, wireframe_density, processing_log): """创建坐标轴的点云表示""" try: axis_length = np.max(extents) * 0.4 axis_thickness = np.min(extents) * 0.005 # 坐标轴厚度 axes_points = [] axes_colors = [] # 计算坐标轴密度 axis_line_density = wireframe_density axis_thickness_points = max(3, wireframe_density // 15) # 厚度方向的点数 # X轴 - 红色（粗线条）- 从点云中心开始 for i in range(axis_line_density): t = i / (axis_line_density - 1) if axis_line_density > 1 else 0 base_point = [origin_center[0] + t * axis_length, origin_center[1], origin_center[2]] # 主轴线 axes_points.append(base_point) axes_colors.append([255, 0, 0, 255]) # 增加厚度（在YZ平面上添加点） for j in range(axis_thickness_points): for k in range(axis_thickness_points): offset_y = (j - axis_thickness_points//2) * axis_thickness / axis_thickness_points offset_z = (k - axis_thickness_points//2) * axis_thickness / axis_thickness_points thick_point = [base_point[0], base_point[1] + offset_y, base_point[2] + offset_z] axes_points.append(thick_point) axes_colors.append([255, 0, 0, 255]) # X轴箭头头部 arrow_length = axis_length * 0.1 arrow_base = axis_length * 0.9 for i in range(axis_line_density // 2): t = i / (axis_line_density // 2 - 1) if axis_line_density > 2 else 0 # 箭头点 arrow_x = origin_center[0] + arrow_base + t * arrow_length arrow_offset = (1 - t) * axis_thickness * 2 axes_points.append([arrow_x, origin_center[1] + arrow_offset, origin_center[2]]) axes_points.append([arrow_x, origin_center[1] - arrow_offset, origin_center[2]]) axes_points.append([arrow_x, origin_center[1], origin_center[2] + arrow_offset]) axes_points.append([arrow_x, origin_center[1], origin_center[2] - arrow_offset]) axes_colors.extend([[255, 0, 0, 255]] * 4) # Y轴 - 绿色（粗线条）- 从点云中心开始 for i in range(axis_line_density): t = i / (axis_line_density - 1) if axis_line_density > 1 else 0 base_point = [origin_center[0], origin_center[1] + t * axis_length, origin_center[2]] # 主轴线 axes_points.append(base_point) axes_colors.append([0, 255, 0, 255]) # 增加厚度（在XZ平面上添加点） for j in range(axis_thickness_points): for k in range(axis_thickness_points): offset_x = (j - axis_thickness_points//2) * axis_thickness / axis_thickness_points offset_z = (k - axis_thickness_points//2) * axis_thickness / axis_thickness_points thick_point = [base_point[0] + offset_x, base_point[1], base_point[2] + offset_z] axes_points.append(thick_point) axes_colors.append([0, 255, 0, 255]) # Y轴箭头头部 for i in range(axis_line_density // 2): t = i / (axis_line_density // 2 - 1) if axis_line_density > 2 else 0 arrow_y = origin_center[1] + arrow_base + t * arrow_length arrow_offset = (1 - t) * axis_thickness * 2 axes_points.append([origin_center[0] + arrow_offset, arrow_y, origin_center[2]]) axes_points.append([origin_center[0] - arrow_offset, arrow_y, origin_center[2]]) axes_points.append([origin_center[0], arrow_y, origin_center[2] + arrow_offset]) axes_points.append([origin_center[0], arrow_y, origin_center[2] - arrow_offset]) axes_colors.extend([[0, 255, 0, 255]] * 4) # Z轴 - 蓝色（粗线条）- 从点云中心开始 for i in range(axis_line_density): t = i / (axis_line_density - 1) if axis_line_density > 1 else 0 base_point = [origin_center[0], origin_center[1], origin_center[2] + t * axis_length] # 主轴线 axes_points.append(base_point) axes_colors.append([0, 0, 255, 255]) # 增加厚度（在XY平面上添加点） for j in range(axis_thickness_points): for k in range(axis_thickness_points): offset_x = (j - axis_thickness_points//2) * axis_thickness / axis_thickness_points offset_y = (k - axis_thickness_points//2) * axis_thickness / axis_thickness_points thick_point = [base_point[0] + offset_x, base_point[1] + offset_y, base_point[2]] axes_points.append(thick_point) axes_colors.append([0, 0, 255, 255]) # Z轴箭头头部 for i in range(axis_line_density // 2): t = i / (axis_line_density // 2 - 1) if axis_line_density > 2 else 0 arrow_z = origin_center[2] + arrow_base + t * arrow_length arrow_offset = (1 - t) * axis_thickness * 2 axes_points.append([origin_center[0] + arrow_offset, origin_center[1], arrow_z]) axes_points.append([origin_center[0] - arrow_offset, origin_center[1], arrow_z]) axes_points.append([origin_center[0], origin_center[1] + arrow_offset, arrow_z]) axes_points.append([origin_center[0], origin_center[1] - arrow_offset, arrow_z]) axes_colors.extend([[0, 0, 255, 255]] * 4) axes_vertices = np.array(axes_points) axes_colors_array = np.array(axes_colors) processing_log.append(f"坐标轴生成: {len(axes_vertices):,} 个点 (长度={axis_length:.3f}, 原点=[{origin_center[0]:.3f}, {origin_center[1]:.3f}, {origin_center[2]:.3f}])") return axes_vertices, axes_colors_array except Exception as e: processing_log.append(f"创建坐标轴点云失败: {str(e)}") return np.array([]), np.array([]) def _generate_output_path(self, output_filename): """生成输出文件路径""" # 确保文件名有正确的扩展名 if not output_filename.lower().endswith('.glb'): output_filename += '.glb' # 生成输出路径 output_dir = folder_paths.get_output_directory() if FOLDER_PATHS_AVAILABLE else "output" os.makedirs(output_dir, exist_ok=True) # 添加时间戳避免文件名冲突 import time timestamp = str(int(time.time())) name_parts = output_filename.rsplit('.', 1) if len(name_parts) == 2: timestamped_filename = f"{name_parts[0]}_{timestamp}.{name_parts[1]}" else: timestamped_filename = f"{output_filename}_{timestamp}" return os.path.join(output_dir, timestamped_filename) class GLBPointCloudOriginAdjuster: """GLB点云原点调整计算器 - 计算原点调整信息并生成带坐标轴的预览文件（原模型数据保持不变）""" @classmethod def INPUT_TYPES(cls): return { "required": { "glb_file_path": ("STRING", { "default": "", "tooltip": "GLB点云文件路径：输入需要调整原点的GLB格式点云文件。注意：此节点在原模型基础上添加坐标轴预览，原模型数据保持不变" }), }, "optional": { "origin_mode": (["center", "bottom_center"], { "default": "bottom_center", "tooltip": "原点模式：center=点云几何中心；bottom_center=点云底部中心(脚底)" }), "output_units": (["meters", "centimeters", "millimeters"], { "default": "centimeters", "tooltip": "输出单位：变换信息的输出单位" }), "add_coordinate_axes": ("BOOLEAN", { "default": True, "tooltip": "添加坐标轴：是否添加RGB坐标轴(X=红色，Y=绿色，Z=蓝色)到输出点云中，显示调整后的原点位置" }), "wireframe_density": ("INT", { "default": 100, "min": 20, "max": 200, "step": 10, "tooltip": "坐标轴密度：每条坐标轴的点数，越高坐标轴越清晰但点数越多。推荐80-120获得清晰效果" }), "output_filename": ("STRING", { "default": "adjusted_pointcloud", "tooltip": "输出文件名：调整后的点云文件名，系统会自动添加.glb扩展名" }), } } RETURN_TYPES = ( "STRING", # 处理后的GLB文件路径 "STRING", # 变换信息JSON (position) ) RETURN_NAMES = ( "adjusted_glb_path", "transform_info", ) OUTPUT_TOOLTIPS = [ "带预览的GLB文件路径 - 包含原始点云+坐标轴预览的完整点云文件", "纯净的position信息JSON: {\"position\": [x, y, z]} - 仅包含位置信息，可直接用于UE等引擎", ] OUTPUT_NODE = True FUNCTION = "adjust_origin" CATEGORY = "💃VVL/Point Cloud Transform" def adjust_origin(self, glb_file_path: str, origin_mode: str = "bottom_center", output_units: str = "centimeters", add_coordinate_axes: bool = False, wireframe_density: int = 100, output_filename: str = "adjusted_pointcloud"): """ 调整GLB点云的原点位置和旋转 """ processing_log = [] processing_log.append("开始GLB点云原点调整...") # 检查依赖 if not TRIMESH_AVAILABLE: error_msg = "trimesh库不可用，无法处理GLB文件" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("", "") # 验证输入文件路径 if not glb_file_path or not glb_file_path.strip(): error_msg = "GLB文件路径为空" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("", "") # 处理文件路径 input_path = self._resolve_file_path(glb_file_path.strip()) processing_log.append(f"输入文件路径: {input_path}") if not os.path.exists(input_path): error_msg = f"GLB文件不存在: {input_path}" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("", "") try: # 加载GLB文件 processing_log.append("正在加载GLB文件...") scene = trimesh.load(input_path) # 收集所有几何体和点云，考虑变换矩阵 geometries_to_transform = [] all_vertices = [] total_points = 0 if isinstance(scene, trimesh.Scene): for node_name in scene.graph.nodes: if node_name in scene.geometry: geometry = scene.geometry[node_name] transform_matrix = scene.graph[node_name][0] # 获取变换矩阵 geometries_to_transform.append((node_name, geometry)) if hasattr(geometry, 'vertices') and geometry.vertices is not None: # 应用变换矩阵获取真实世界坐标 if transform_matrix is not None and not np.allclose(transform_matrix, np.eye(4)): world_vertices = trimesh.transformations.transform_points(geometry.vertices, transform_matrix) processing_log.append(f"发现几何体: {node_name}, 顶点数: {len(geometry.vertices)}, 已应用变换矩阵") else: world_vertices = geometry.vertices.copy() processing_log.append(f"发现几何体: {node_name}, 顶点数: {len(geometry.vertices)}, 无变换") all_vertices.append(world_vertices) total_points += len(geometry.vertices) else: # 单个几何体 geometries_to_transform.append(("main_geometry", scene)) if hasattr(scene, 'vertices') and scene.vertices is not None: all_vertices.append(scene.vertices) total_points = len(scene.vertices) processing_log.append(f"发现几何体: main_geometry, 顶点数: {total_points}") if not all_vertices: error_msg = "GLB文件中没有可用的顶点数据" processing_log.append(f"错误: {error_msg}") return ("", "") # 合并所有顶点计算包围盒（已经是世界坐标） combined_vertices = np.vstack(all_vertices) processing_log.append(f"总顶点数: {total_points:,} (已应用变换矩阵)") # 计算原始包围盒 original_min = np.min(combined_vertices, axis=0) original_max = np.max(combined_vertices, axis=0) original_center = (original_min + original_max) / 2 original_size = original_max - original_min processing_log.append(f"原始包围盒:") processing_log.append(f" 最小点: [{original_min[0]:.6f}, {original_min[1]:.6f}, {original_min[2]:.6f}]") processing_log.append(f" 最大点: [{original_max[0]:.6f}, {original_max[1]:.6f}, {original_max[2]:.6f}]") processing_log.append(f" 中心点: [{original_center[0]:.6f}, {original_center[1]:.6f}, {original_center[2]:.6f}]") processing_log.append(f" 尺寸: [{original_size[0]:.6f}, {original_size[1]:.6f}, {original_size[2]:.6f}]") # 确定新的原点位置 if origin_mode == "center": new_origin = original_center.copy() processing_log.append("原点模式: 几何中心") else: # bottom_center new_origin = np.array([original_center[0], original_center[1], original_min[2]]) processing_log.append("原点模式: 底部中心(脚底)") # 计算平移向量 translation = -new_origin processing_log.append(f"平移向量: [{translation[0]:.6f}, {translation[1]:.6f}, {translation[2]:.6f}]") # 创建平移变换矩阵（仅平移，无旋转） transform_matrix = np.eye(4) transform_matrix[:3, 3] = translation # 应用变换到所有几何体 new_scene = trimesh.Scene() transformed_vertices_list = [] for name, geometry in geometries_to_transform: # 复制几何体 new_geometry = geometry.copy() # 应用变换 new_geometry.apply_transform(transform_matrix) # 添加到新场景 new_scene.add_geometry(new_geometry, node_name=name) # 收集变换后的顶点用于统计 if hasattr(new_geometry, 'vertices') and new_geometry.vertices is not None: transformed_vertices_list.append(new_geometry.vertices) processing_log.append(f"已变换几何体: {name}") # 添加坐标轴预览（在变换后的原点位置，即(0,0,0)） if add_coordinate_axes: try: # 计算变换后的包围盒来确定坐标轴长度 if transformed_vertices_list: all_transformed_vertices = np.vstack(transformed_vertices_list) transformed_extents = np.max(all_transformed_vertices, axis=0) - np.min(all_transformed_vertices, axis=0) axis_length = np.max(transformed_extents) * 0.4 else: axis_length = 1.0 # 默认长度 # 在新的原点(0,0,0)处生成坐标轴 axes_vertices, axes_colors = self._create_coordinate_axes_pointcloud_at_origin( axis_length, wireframe_density, processing_log ) if len(axes_vertices) > 0: # 创建坐标轴点云 axes_pointcloud = trimesh.PointCloud(vertices=axes_vertices, colors=axes_colors) new_scene.add_geometry(axes_pointcloud, node_name="coordinate_axes") processing_log.append(f"坐标轴预览: {len(axes_vertices):,} 个点 (显示新的原点位置)") except Exception as e: processing_log.append(f"坐标轴生成失败: {str(e)}") # 计算变换后的包围盒 if transformed_vertices_list: transformed_vertices = np.vstack(transformed_vertices_list) new_min = np.min(transformed_vertices, axis=0) new_max = np.max(transformed_vertices, axis=0) new_center = (new_min + new_max) / 2 new_size = new_max - new_min processing_log.append(f"变换后包围盒:") processing_log.append(f" 最小点: [{new_min[0]:.6f}, {new_min[1]:.6f}, {new_min[2]:.6f}]") processing_log.append(f" 最大点: [{new_max[0]:.6f}, {new_max[1]:.6f}, {new_max[2]:.6f}]") processing_log.append(f" 中心点: [{new_center[0]:.6f}, {new_center[1]:.6f}, {new_center[2]:.6f}]") processing_log.append(f" 尺寸: [{new_size[0]:.6f}, {new_size[1]:.6f}, {new_size[2]:.6f}]") # 生成带预览的输出文件（原模型数据不变，仅添加坐标轴预览） output_path = self._generate_output_path(output_filename) processing_log.append(f"输出文件路径: {output_path}") # 创建包含原始点云和坐标轴的预览场景，完全保持原始结构 original_scene = trimesh.load(input_path) # 重新加载原始场景 # 创建预览场景，完全复制原始场景的结构 if isinstance(original_scene, trimesh.Scene): preview_scene = trimesh.Scene() # 完全复制原始场景的所有几何体和变换矩阵 for node_name in original_scene.graph.nodes: if node_name in original_scene.geometry: geometry = original_scene.geometry[node_name] transform_matrix = original_scene.graph[node_name][0] # 获取变换矩阵 # 完全复制几何体，保持所有属性 copied_geometry = geometry.copy() # 添加到预览场景，保持原始的变换矩阵 preview_scene.add_geometry(copied_geometry, node_name=node_name, transform=transform_matrix) processing_log.append(f"完全保持原始几何体: {node_name}, 变换矩阵和朝向已保留") else: # 单个几何体的情况 preview_scene = trimesh.Scene() preview_scene.add_geometry(original_scene.copy(), node_name="main_geometry") processing_log.append("完全保持原始几何体: main_geometry, 所有属性已保留") # 添加坐标轴预览（如果需要） if add_coordinate_axes: try: # 使用原始包围盒来确定坐标轴长度 axis_length = np.max(original_size) * 0.4 # 在计算出的新原点位置生成坐标轴 axes_vertices, axes_colors = self._create_coordinate_axes_pointcloud_at_position( new_origin, axis_length, wireframe_density, processing_log ) if len(axes_vertices) > 0: # 创建坐标轴点云并添加到场景 axes_pointcloud = trimesh.PointCloud(vertices=axes_vertices, colors=axes_colors) preview_scene.add_geometry(axes_pointcloud, node_name="coordinate_axes_preview") processing_log.append(f"坐标轴预览: {len(axes_vertices):,} 个点 (显示建议的新原点位置)") except Exception as e: processing_log.append(f"坐标轴生成失败: {str(e)}") # 保存预览文件 processing_log.append("正在保存带预览的GLB文件...") preview_scene.export(output_path) if os.path.exists(output_path): file_size = os.path.getsize(output_path) processing_log.append(f"预览GLB文件保存成功，文件大小: {file_size} bytes") else: error_msg = "预览GLB文件保存失败" processing_log.append(f"错误: {error_msg}") return ("", "") # 应用单位转换 unit_scale = {"meters": 1.0, "centimeters": 100.0, "millimeters": 1000.0} scale_factor = unit_scale.get(output_units, 1.0) # 生成变换信息（UE格式） final_position = new_origin * scale_factor # 相对于原始坐标系的位置 transform_info = { "name": output_filename, "position": [float(final_position[0]), float(final_position[1]), float(final_position[2])] } processing_log.append("") processing_log.append(f"变换信息 (单位: {output_units}):") processing_log.append(f" Position: [{transform_info['position'][0]:.2f}, {transform_info['position'][1]:.2f}, {transform_info['position'][2]:.2f}]") processing_log.append("原点调整预览生成完成!") return ( output_path, json.dumps(transform_info, indent=2), ) except Exception as e: error_msg = f"调整原点时发生错误: {str(e)}" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") import traceback traceback.print_exc() return ("", "") def _resolve_file_path(self, file_path: str) -> str: """解析文件路径，支持绝对路径和相对路径""" if os.path.isabs(file_path): return file_path # 尝试相对于ComfyUI输出目录 if FOLDER_PATHS_AVAILABLE: output_dir = folder_paths.get_output_directory() candidate_path = os.path.join(output_dir, file_path) if os.path.exists(candidate_path): return candidate_path # 尝试相对于当前工作目录 if os.path.exists(file_path): return os.path.abspath(file_path) # 返回原始路径（让后续检查处理错误） return file_path def _generate_output_path(self, filename: str) -> str: """生成输出文件路径""" # 确保文件名有正确的扩展名 if not filename.lower().endswith('.glb'): filename += '.glb' # 生成输出路径 output_dir = folder_paths.get_output_directory() if FOLDER_PATHS_AVAILABLE else "output" os.makedirs(output_dir, exist_ok=True) # 添加时间戳避免文件名冲突 timestamp = str(int(time.time())) name_parts = filename.rsplit('.', 1) if len(name_parts) == 2: timestamped_filename = f"{name_parts[0]}_{timestamp}.{name_parts[1]}" else: timestamped_filename = f"{filename}_{timestamp}" return os.path.join(output_dir, timestamped_filename) def _create_coordinate_axes_pointcloud_at_position(self, position, axis_length, wireframe_density, processing_log): """在指定位置创建坐标轴的点云表示""" try: center = np.array(position) # 指定的位置 axis_thickness = axis_length * 0.01 # 坐标轴厚度 axes_points = [] axes_colors = [] # 计算坐标轴密度 axis_line_density = wireframe_density # 使用参数控制密度 axis_thickness_points = max(3, axis_line_density // 15) # 厚度方向的点数 # X轴 - 红色（从指定位置开始） for i in range(axis_line_density): t = i / (axis_line_density - 1) if axis_line_density > 1 else 0 base_point = [center[0] + t * axis_length, center[1], center[2]] # 主轴线 axes_points.append(base_point) axes_colors.append([255, 0, 0, 255]) # 增加厚度（在YZ平面上添加点） for j in range(axis_thickness_points): for k in range(axis_thickness_points): offset_y = (j - axis_thickness_points//2) * axis_thickness / axis_thickness_points offset_z = (k - axis_thickness_points//2) * axis_thickness / axis_thickness_points thick_point = [base_point[0], base_point[1] + offset_y, base_point[2] + offset_z] axes_points.append(thick_point) axes_colors.append([255, 0, 0, 255]) # X轴箭头头部 arrow_length = axis_length * 0.1 arrow_base = axis_length * 0.9 for i in range(axis_line_density // 2): t = i / (axis_line_density // 2 - 1) if axis_line_density > 2 else 0 arrow_x = center[0] + arrow_base + t * arrow_length arrow_offset = (1 - t) * axis_thickness * 2 axes_points.append([arrow_x, center[1] + arrow_offset, center[2]]) axes_points.append([arrow_x, center[1] - arrow_offset, center[2]]) axes_points.append([arrow_x, center[1], center[2] + arrow_offset]) axes_points.append([arrow_x, center[1], center[2] - arrow_offset]) axes_colors.extend([[255, 0, 0, 255]] * 4) # Y轴 - 绿色（从指定位置开始） for i in range(axis_line_density): t = i / (axis_line_density - 1) if axis_line_density > 1 else 0 base_point = [center[0], center[1] + t * axis_length, center[2]] # 主轴线 axes_points.append(base_point) axes_colors.append([0, 255, 0, 255]) # 增加厚度（在XZ平面上添加点） for j in range(axis_thickness_points): for k in range(axis_thickness_points): offset_x = (j - axis_thickness_points//2) * axis_thickness / axis_thickness_points offset_z = (k - axis_thickness_points//2) * axis_thickness / axis_thickness_points thick_point = [base_point[0] + offset_x, base_point[1], base_point[2] + offset_z] axes_points.append(thick_point) axes_colors.append([0, 255, 0, 255]) # Y轴箭头头部 for i in range(axis_line_density // 2): t = i / (axis_line_density // 2 - 1) if axis_line_density > 2 else 0 arrow_y = center[1] + arrow_base + t * arrow_length arrow_offset = (1 - t) * axis_thickness * 2 axes_points.append([center[0] + arrow_offset, arrow_y, center[2]]) axes_points.append([center[0] - arrow_offset, arrow_y, center[2]]) axes_points.append([center[0], arrow_y, center[2] + arrow_offset]) axes_points.append([center[0], arrow_y, center[2] - arrow_offset]) axes_colors.extend([[0, 255, 0, 255]] * 4) # Z轴 - 蓝色（从指定位置开始） for i in range(axis_line_density): t = i / (axis_line_density - 1) if axis_line_density > 1 else 0 base_point = [center[0], center[1], center[2] + t * axis_length] # 主轴线 axes_points.append(base_point) axes_colors.append([0, 0, 255, 255]) # 增加厚度（在XY平面上添加点） for j in range(axis_thickness_points): for k in range(axis_thickness_points): offset_x = (j - axis_thickness_points//2) * axis_thickness / axis_thickness_points offset_y = (k - axis_thickness_points//2) * axis_thickness / axis_thickness_points thick_point = [base_point[0] + offset_x, base_point[1] + offset_y, base_point[2]] axes_points.append(thick_point) axes_colors.append([0, 0, 255, 255]) # Z轴箭头头部 for i in range(axis_line_density // 2): t = i / (axis_line_density // 2 - 1) if axis_line_density > 2 else 0 arrow_z = center[2] + arrow_base + t * arrow_length arrow_offset = (1 - t) * axis_thickness * 2 axes_points.append([center[0] + arrow_offset, center[1], arrow_z]) axes_points.append([center[0] - arrow_offset, center[1], arrow_z]) axes_points.append([center[0], center[1] + arrow_offset, arrow_z]) axes_points.append([center[0], center[1] - arrow_offset, arrow_z]) axes_colors.extend([[0, 0, 255, 255]] * 4) axes_vertices = np.array(axes_points) axes_colors_array = np.array(axes_colors) processing_log.append(f"坐标轴生成: {len(axes_vertices):,} 个点 (长度={axis_length:.3f}, 密度={wireframe_density}, 位置=[{center[0]:.3f}, {center[1]:.3f}, {center[2]:.3f}])") return axes_vertices, axes_colors_array except Exception as e: processing_log.append(f"创建坐标轴点云失败: {str(e)}") return np.array([]), np.array([]) def _create_coordinate_axes_pointcloud_at_origin(self, axis_length, wireframe_density, processing_log): """在原点(0,0,0)创建坐标轴的点云表示""" try: origin_center = np.array([0.0, 0.0, 0.0]) # 新的原点位置 axis_thickness = axis_length * 0.01 # 坐标轴厚度 axes_points = [] axes_colors = [] # 计算坐标轴密度 axis_line_density = wireframe_density # 使用参数控制密度 axis_thickness_points = max(3, axis_line_density // 15) # 厚度方向的点数 # X轴 - 红色（从原点开始） for i in range(axis_line_density): t = i / (axis_line_density - 1) if axis_line_density > 1 else 0 base_point = [origin_center[0] + t * axis_length, origin_center[1], origin_center[2]] # 主轴线 axes_points.append(base_point) axes_colors.append([255, 0, 0, 255]) # 增加厚度（在YZ平面上添加点） for j in range(axis_thickness_points): for k in range(axis_thickness_points): offset_y = (j - axis_thickness_points//2) * axis_thickness / axis_thickness_points offset_z = (k - axis_thickness_points//2) * axis_thickness / axis_thickness_points thick_point = [base_point[0], base_point[1] + offset_y, base_point[2] + offset_z] axes_points.append(thick_point) axes_colors.append([255, 0, 0, 255]) # X轴箭头头部 arrow_length = axis_length * 0.1 arrow_base = axis_length * 0.9 for i in range(axis_line_density // 2): t = i / (axis_line_density // 2 - 1) if axis_line_density > 2 else 0 arrow_x = origin_center[0] + arrow_base + t * arrow_length arrow_offset = (1 - t) * axis_thickness * 2 axes_points.append([arrow_x, origin_center[1] + arrow_offset, origin_center[2]]) axes_points.append([arrow_x, origin_center[1] - arrow_offset, origin_center[2]]) axes_points.append([arrow_x, origin_center[1], origin_center[2] + arrow_offset]) axes_points.append([arrow_x, origin_center[1], origin_center[2] - arrow_offset]) axes_colors.extend([[255, 0, 0, 255]] * 4) # Y轴 - 绿色（从原点开始） for i in range(axis_line_density): t = i / (axis_line_density - 1) if axis_line_density > 1 else 0 base_point = [origin_center[0], origin_center[1] + t * axis_length, origin_center[2]] # 主轴线 axes_points.append(base_point) axes_colors.append([0, 255, 0, 255]) # 增加厚度（在XZ平面上添加点） for j in range(axis_thickness_points): for k in range(axis_thickness_points): offset_x = (j - axis_thickness_points//2) * axis_thickness / axis_thickness_points offset_z = (k - axis_thickness_points//2) * axis_thickness / axis_thickness_points thick_point = [base_point[0] + offset_x, base_point[1], base_point[2] + offset_z] axes_points.append(thick_point) axes_colors.append([0, 255, 0, 255]) # Y轴箭头头部 for i in range(axis_line_density // 2): t = i / (axis_line_density // 2 - 1) if axis_line_density > 2 else 0 arrow_y = origin_center[1] + arrow_base + t * arrow_length arrow_offset = (1 - t) * axis_thickness * 2 axes_points.append([origin_center[0] + arrow_offset, arrow_y, origin_center[2]]) axes_points.append([origin_center[0] - arrow_offset, arrow_y, origin_center[2]]) axes_points.append([origin_center[0], arrow_y, origin_center[2] + arrow_offset]) axes_points.append([origin_center[0], arrow_y, origin_center[2] - arrow_offset]) axes_colors.extend([[0, 255, 0, 255]] * 4) # Z轴 - 蓝色（从原点开始） for i in range(axis_line_density): t = i / (axis_line_density - 1) if axis_line_density > 1 else 0 base_point = [origin_center[0], origin_center[1], origin_center[2] + t * axis_length] # 主轴线 axes_points.append(base_point) axes_colors.append([0, 0, 255, 255]) # 增加厚度（在XY平面上添加点） for j in range(axis_thickness_points): for k in range(axis_thickness_points): offset_x = (j - axis_thickness_points//2) * axis_thickness / axis_thickness_points offset_y = (k - axis_thickness_points//2) * axis_thickness / axis_thickness_points thick_point = [base_point[0] + offset_x, base_point[1] + offset_y, base_point[2]] axes_points.append(thick_point) axes_colors.append([0, 0, 255, 255]) # Z轴箭头头部 for i in range(axis_line_density // 2): t = i / (axis_line_density // 2 - 1) if axis_line_density > 2 else 0 arrow_z = origin_center[2] + arrow_base + t * arrow_length arrow_offset = (1 - t) * axis_thickness * 2 axes_points.append([origin_center[0] + arrow_offset, origin_center[1], arrow_z]) axes_points.append([origin_center[0] - arrow_offset, origin_center[1], arrow_z]) axes_points.append([origin_center[0], origin_center[1] + arrow_offset, arrow_z]) axes_points.append([origin_center[0], origin_center[1] - arrow_offset, arrow_z]) axes_colors.extend([[0, 0, 255, 255]] * 4) axes_vertices = np.array(axes_points) axes_colors_array = np.array(axes_colors) processing_log.append(f"坐标轴生成: {len(axes_vertices):,} 个点 (长度={axis_length:.3f}, 密度={wireframe_density}, 原点=[0.000, 0.000, 0.000])") return axes_vertices, axes_colors_array except Exception as e: processing_log.append(f"创建坐标轴点云失败: {str(e)}") return np.array([]), np.array([]) class GLBPointCloudDensityFilter: """GLB点云密度过滤器 - 根据局部密度删除稀疏区域，保留密度最高的核心区域""" @classmethod def INPUT_TYPES(cls): return { "required": { "glb_file_path": ("STRING", { "default": "", "tooltip": "GLB点云文件路径：输入需要进行密度过滤的GLB格式点云文件。支持绝对路径或相对于ComfyUI output目录的相对路径" }), }, "optional": { "density_threshold": ("FLOAT", { "default": 0.3, "min": 0.01, "max": 0.99, "step": 0.01, "tooltip": "密度阈值：保留密度高于此比例的点。0.3=保留密度前70%的点；0.5=保留密度前50%的点。值越大删除越多稀疏点" }), "neighborhood_radius": ("FLOAT", { "default": 0.1, "min": 0.01, "max": 1.0, "step": 0.01, "tooltip": "邻域半径：计算密度时的搜索半径。较小值=精细密度检测；较大值=平滑密度检测。建议0.05-0.2" }), "min_neighbors": ("INT", { "default": 5, "min": 1, "max": 50, "step": 1, "tooltip": "最小邻居数：一个点在邻域内至少需要的邻居点数量才不被视为稀疏点。值越大要求密度越高" }), "preserve_core_percentage": ("FLOAT", { "default": 0.8, "min": 0.1, "max": 1.0, "step": 0.05, "tooltip": "核心区域保留比例：无论密度如何，都会保留密度最高的这部分点。0.8=保证保留最密集的80%区域" }), "use_adaptive_radius": ("BOOLEAN", { "default": True, "tooltip": "自适应半径：根据点云整体尺寸自动调整邻域半径，确保在不同尺寸的点云上都有良好效果" }), "output_filename": ("STRING", { "default": "density_filtered_pointcloud", "tooltip": "输出GLB文件名：密度过滤后点云的保存文件名，系统会自动添加.glb扩展名" }), } } RETURN_TYPES = ( "STRING", # 处理后的GLB文件路径 "STRING", # 过滤统计信息JSON ) RETURN_NAMES = ( "filtered_glb_path", "filter_stats", ) OUTPUT_TOOLTIPS = [ "密度过滤后的GLB文件完整路径", "过滤统计信息JSON：包含原始点数、保留点数、删除点数等统计数据", ] OUTPUT_NODE = True FUNCTION = "filter_by_density" CATEGORY = "💃VVL/Point Cloud Filtering" def filter_by_density(self, glb_file_path: str, density_threshold: float = 0.3, neighborhood_radius: float = 0.1, min_neighbors: int = 5, preserve_core_percentage: float = 0.8, use_adaptive_radius: bool = True, output_filename: str = "density_filtered_pointcloud"): """ 根据局部密度过滤GLB点云文件，删除稀疏区域 """ processing_log = [] processing_log.append("开始GLB点云密度过滤...") # 检查依赖 if not TRIMESH_AVAILABLE: error_msg = "trimesh库不可用，无法处理GLB文件" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("", "") # 验证输入文件路径 if not glb_file_path or not glb_file_path.strip(): error_msg = "GLB文件路径为空" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("", "") # 处理文件路径 input_path = self._resolve_file_path(glb_file_path.strip()) processing_log.append(f"输入文件路径: {input_path}") if not os.path.exists(input_path): error_msg = f"GLB文件不存在: {input_path}" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") return ("", "") try: # 加载GLB文件 processing_log.append("正在加载GLB文件...") scene = trimesh.load(input_path) # 提取点云数据 point_clouds = [] other_geometries = [] if isinstance(scene, trimesh.Scene): for name, geometry in scene.geometry.items(): if isinstance(geometry, trimesh.PointCloud): point_clouds.append((name, geometry)) processing_log.append(f"发现点云: {name}, 点数: {len(geometry.vertices)}") else: other_geometries.append((name, geometry)) elif isinstance(scene, trimesh.PointCloud): point_clouds.append(("main_pointcloud", scene)) processing_log.append(f"发现点云: main_pointcloud, 点数: {len(scene.vertices)}") else: # 尝试转换为点云 if hasattr(scene, 'vertices'): pc = trimesh.PointCloud(vertices=scene.vertices, colors=getattr(scene.visual, 'vertex_colors', None)) point_clouds.append(("converted_pointcloud", pc)) processing_log.append(f"转换为点云: converted_pointcloud, 点数: {len(pc.vertices)}") else: error_msg = "GLB文件中未找到点云数据" processing_log.append(f"错误: {error_msg}") return ("", "") if not point_clouds: error_msg = "GLB文件中没有点云数据" processing_log.append(f"错误: {error_msg}") return ("", "") # 处理每个点云 filtered_point_clouds = [] total_original_points = 0 total_filtered_points = 0 for name, point_cloud in point_clouds: processing_log.append(f"\n处理点云: {name}") original_count = len(point_cloud.vertices) total_original_points += original_count # 获取原始点云的所有属性和状态 original_vertices = point_cloud.vertices.copy() colors = None # 获取颜色信息 if hasattr(point_cloud.visual, 'vertex_colors') and point_cloud.visual.vertex_colors is not None: colors = point_cloud.visual.vertex_colors.copy() elif hasattr(point_cloud, 'colors') and point_cloud.colors is not None: colors = point_cloud.colors.copy() # 应用密度过滤（仅基于密度，不改变顶点坐标） keep_mask, filter_info = self._apply_density_filter( original_vertices, colors, density_threshold, neighborhood_radius, min_neighbors, preserve_core_percentage, use_adaptive_radius, processing_log ) # 应用掩码，保留原始的顶点坐标 filtered_vertices = original_vertices[keep_mask] filtered_colors = colors[keep_mask] if colors is not None else None filtered_count = len(filtered_vertices) total_filtered_points += filtered_count processing_log.append(f"点云 {name}: 原始 {original_count} -> 保留 {filtered_count} (删除 {original_count - filtered_count})") # 创建过滤后的点云，保留所有原始属性 if filtered_count > 0: # 使用原始点云作为模板，只更新顶点和颜色 filtered_pc = point_cloud.copy() filtered_pc.vertices = filtered_vertices if filtered_colors is not None: filtered_pc.visual.vertex_colors = filtered_colors filtered_point_clouds.append((name, filtered_pc)) processing_log.append(f"保留点云 {name} 的所有原始属性和状态") else: processing_log.append(f"警告: 点云 {name} 过滤后没有剩余点") # 直接修改原始场景，保持所有几何信息不变 if filtered_point_clouds: # 使用原始场景作为基础，直接替换点云数据 new_scene = scene # 直接修改原始场景中的点云几何体，保持变换不变 for name, filtered_pc in filtered_point_clouds: if isinstance(scene, trimesh.Scene): # 获取原始几何体 if name in scene.geometry: original_geometry = scene.geometry[name] # 如果是点云，直接修改顶点和颜色 if isinstance(original_geometry, trimesh.PointCloud): original_geometry.vertices = filtered_pc.vertices if hasattr(filtered_pc.visual, 'vertex_colors') and filtered_pc.visual.vertex_colors is not None: original_geometry.visual.vertex_colors = filtered_pc.visual.vertex_colors processing_log.append(f"直接修改原始点云 {name}，保持所有变换和属性不变") else: # 如果不是点云类型，替换整个几何体但保持变换 scene.delete_geometry(name) scene.add_geometry(filtered_pc, node_name=name) processing_log.append(f"替换几何体 {name}，尝试保持变换") else: # 新增几何体 scene.add_geometry(filtered_pc, node_name=name) processing_log.append(f"添加新点云 {name}") else: # 单个几何体的情况 new_scene = filtered_pc processing_log.append("单个几何体，直接使用过滤后的点云") processing_log.append("直接修改原始场景，所有变换矩阵和几何属性完全保持不变") # 生成输出路径 output_path = self._generate_output_path(output_filename) processing_log.append(f"输出文件路径: {output_path}") # 保存过滤后的GLB文件 processing_log.append("正在保存过滤后的GLB文件...") new_scene.export(output_path) # 验证文件是否保存成功 if os.path.exists(output_path): file_size = os.path.getsize(output_path) processing_log.append(f"GLB文件保存成功，文件大小: {file_size} bytes") # 生成统计信息 filter_stats = { "original_points": total_original_points, "filtered_points": total_filtered_points, "removed_points": total_original_points - total_filtered_points, "retention_rate": total_filtered_points / total_original_points if total_original_points > 0 else 0, "parameters": { "density_threshold": density_threshold, "neighborhood_radius": neighborhood_radius, "min_neighbors": min_neighbors, "preserve_core_percentage": preserve_core_percentage, "use_adaptive_radius": use_adaptive_radius } } stats_json = json.dumps(filter_stats, indent=2) processing_log.append("GLB点云密度过滤完成! 已保留原始模型的大小、朝向和几何属性") processing_log.append(f"统计: 原始{total_original_points}点 -> 保留{total_filtered_points}点 (保留率: {filter_stats['retention_rate']:.1%})") return (output_path, stats_json) else: error_msg = "GLB文件保存失败" processing_log.append(f"错误: {error_msg}") return ("", "") else: error_msg = "过滤后没有剩余的点云数据" processing_log.append(f"错误: {error_msg}") return ("", "") except Exception as e: error_msg = f"处理GLB文件时发生错误: {str(e)}" logger.error(error_msg) processing_log.append(f"错误: {error_msg}") import traceback traceback.print_exc() return ("", "") def _apply_density_filter(self, vertices, colors, density_threshold, neighborhood_radius, min_neighbors, preserve_core_percentage, use_adaptive_radius, processing_log): """ 应用密度过滤算法，返回保留点的掩码 """ n_points = len(vertices) processing_log.append(f"开始密度分析，总点数: {n_points}") # 自适应半径调整 if use_adaptive_radius: # 计算点云的包围盒对角线长度 bbox_min = np.min(vertices, axis=0) bbox_max = np.max(vertices, axis=0) bbox_diagonal = np.linalg.norm(bbox_max - bbox_min) # 根据包围盒大小调整半径 adaptive_radius = neighborhood_radius * bbox_diagonal / 10.0 # 可调整的比例因子 processing_log.append(f"自适应半径: {neighborhood_radius} -> {adaptive_radius:.4f} (基于包围盒对角线 {bbox_diagonal:.4f})") neighborhood_radius = adaptive_radius # 使用KDTree进行高效的邻域搜索 try: from scipy.spatial import cKDTree kdtree = cKDTree(vertices) processing_log.append("使用scipy.spatial.cKDTree进行邻域搜索") except ImportError: processing_log.append("scipy不可用，使用简化的距离计算") kdtree = None # 计算每个点的局部密度 densities = np.zeros(n_points) if kdtree is not None: # 高效的KDTree搜索 for i in range(n_points): # 查找邻域内的点 neighbor_indices = kdtree.query_ball_point(vertices[i], neighborhood_radius) densities[i] = len(neighbor_indices) - 1 # 减去自己 else: # 简化的距离计算（适用于小点云） for i in range(n_points): distances = np.linalg.norm(vertices - vertices[i], axis=1) neighbor_count = np.sum(distances <= neighborhood_radius) - 1 # 减去自己 densities[i] = neighbor_count processing_log.append(f"密度统计: 最小={densities.min():.1f}, 最大={densities.max():.1f}, 平均={densities.mean():.1f}") # 应用多层过滤策略 keep_mask = np.ones(n_points, dtype=bool) # 1. 基于最小邻居数的过滤 min_neighbor_mask = densities >= min_neighbors removed_by_min_neighbors = np.sum(~min_neighbor_mask) keep_mask &= min_neighbor_mask processing_log.append(f"最小邻居数过滤: 删除 {removed_by_min_neighbors} 个点") # 2. 基于密度阈值的过滤 if density_threshold > 0 and np.sum(keep_mask) > 0: valid_densities = densities[keep_mask] density_percentile = np.percentile(valid_densities, (1 - density_threshold) * 100) density_mask = densities >= density_percentile # 保留当前mask中的点，再应用密度过滤 temp_mask = keep_mask.copy() keep_mask[temp_mask] &= density_mask[temp_mask] removed_by_density = np.sum(temp_mask) - np.sum(keep_mask) processing_log.append(f"密度阈值过滤: 删除 {removed_by_density} 个点 (阈值密度: {density_percentile:.1f})") # 3. 核心区域保护 if preserve_core_percentage < 1.0 and np.sum(keep_mask) > 0: # 计算需要保留的核心点数 target_core_points = int(n_points * preserve_core_percentage) current_points = np.sum(keep_mask) if current_points < target_core_points: # 当前保留的点数少于核心要求，需要添加高密度点 need_more_points = target_core_points - current_points # 找到密度最高的点 excluded_indices = np.where(~keep_mask)[0] if len(excluded_indices) > 0: excluded_densities = densities[excluded_indices] # 按密度排序，选择密度最高的点 sorted_indices = excluded_indices[np.argsort(-excluded_densities)] points_to_restore = min(need_more_points, len(sorted_indices)) keep_mask[sorted_indices[:points_to_restore]] = True processing_log.append(f"核心区域保护: 恢复 {points_to_restore} 个高密度点") # 统计信息 original_count = n_points filtered_count = np.sum(keep_mask) removed_count = original_count - filtered_count filter_info = { "original_points": original_count, "filtered_points": filtered_count, "removed_points": removed_count, "retention_rate": filtered_count / original_count if original_count > 0 else 0, "density_stats": { "min": float(densities.min()), "max": float(densities.max()), "mean": float(densities.mean()), "std": float(densities.std()) } } processing_log.append(f"密度过滤完成: 保留 {filtered_count}/{original_count} 点 (保留率: {filter_info['retention_rate']:.1%})") return keep_mask, filter_info def _resolve_file_path(self, file_path: str) -> str: """解析文件路径，支持绝对路径和相对路径""" if os.path.isabs(file_path): return file_path # 尝试相对于ComfyUI输出目录 if FOLDER_PATHS_AVAILABLE: output_dir = folder_paths.get_output_directory() candidate_path = os.path.join(output_dir, file_path) if os.path.exists(candidate_path): return candidate_path # 尝试相对于当前工作目录 if os.path.exists(file_path): return os.path.abspath(file_path) # 返回原始路径（让后续检查处理错误） return file_path def _generate_output_path(self, filename: str) -> str: """生成输出文件路径""" if FOLDER_PATHS_AVAILABLE: output_dir = folder_paths.get_output_directory() else: output_dir = "output" # 确保输出目录存在 os.makedirs(output_dir, exist_ok=True) # 处理文件名，确保是.glb扩展名 if not filename.lower().endswith('.glb'): filename = f"{filename}.glb" return os.path.join(output_dir, filename) # ----------------------------------------------------------------------------- # 节点注册 - 更新注册信息 # ----------------------------------------------------------------------------- NODE_CLASS_MAPPINGS = { "GLBPointCloudProcessor": GLBPointCloudProcessor, "GLBPointCloudBounds": GLBPointCloudBounds, "GLBPointCloudOriginAdjuster": GLBPointCloudOriginAdjuster, "GLBPointCloudDensityFilter": GLBPointCloudDensityFilter, } NODE_DISPLAY_NAME_MAPPINGS = { "GLBPointCloudProcessor": "VVL GLB Point Cloud Processor", "GLBPointCloudBounds": "VVL GLB Point Cloud Bounds Visualizer", "GLBPointCloudOriginAdjuster": "VVL GLB Point Cloud Origin Adjuster", "GLBPointCloudDensityFilter": "VVL GLB Point Cloud Density Filter", } # # 添加节点信息，帮助ComfyUI更好地识别 # WEB_DIRECTORY = "./web" # __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]