1382 lines
66 KiB
Python
Executable File
1382 lines
66 KiB
Python
Executable File
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.glb",
|
|
"tooltip": "输出GLB文件名：处理后点云的保存文件名，自动添加.glb扩展名。文件将保存到ComfyUI的output目录中。建议使用描述性名称如'clean_pointcloud.glb'、'filtered_scan.glb'等便于识别"
|
|
}),
|
|
}
|
|
}
|
|
|
|
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"):
|
|
"""
|
|
处理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
|
|
|
|
# 获取顶点和颜色
|
|
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(vertices), dtype=bool)
|
|
|
|
# 删除暗色点（默认启用）
|
|
if colors is not None:
|
|
removed_count = self._remove_dark_points(vertices, colors, keep_mask, black_threshold, processing_log)
|
|
processing_log.append(f"删除黑色点: {removed_count} 个")
|
|
else:
|
|
processing_log.append("跳过黑色点过滤: 点云无颜色信息")
|
|
|
|
# 应用掩码
|
|
filtered_vertices = 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 = trimesh.PointCloud(vertices=filtered_vertices, colors=filtered_colors)
|
|
processed_point_clouds.append((name, processed_pc))
|
|
else:
|
|
processing_log.append(f"警告: 点云 {name} 处理后没有剩余点")
|
|
|
|
# 创建新的场景
|
|
if processed_point_clouds:
|
|
new_scene = trimesh.Scene()
|
|
|
|
# 添加处理后的点云
|
|
for name, pc in processed_point_clouds:
|
|
new_scene.add_geometry(pc, node_name=name)
|
|
|
|
# 添加其他几何体（如相机模型）
|
|
for name, geometry in other_geometries:
|
|
new_scene.add_geometry(geometry, node_name=name)
|
|
processing_log.append(f"保留几何体: {name}")
|
|
|
|
# 生成输出路径
|
|
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")
|
|
|
|
|
|
|
|
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.glb",
|
|
"tooltip": "输出文件名：带包围盒可视化的点云文件名"
|
|
}),
|
|
}
|
|
}
|
|
|
|
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"):
|
|
"""
|
|
计算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 name, geometry in scene.geometry.items():
|
|
if isinstance(geometry, trimesh.PointCloud):
|
|
all_vertices.append(geometry.vertices)
|
|
point_cloud_count += 1
|
|
processing_log.append(f"发现点云: {name}, 点数: {len(geometry.vertices)}")
|
|
elif hasattr(geometry, 'vertices') and geometry.vertices is not None:
|
|
# 处理可能被转换为Mesh的点云
|
|
all_vertices.append(geometry.vertices)
|
|
point_cloud_count += 1
|
|
processing_log.append(f"发现几何体(作为点云处理): {name}, 点数: {len(geometry.vertices)}")
|
|
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] # 变换矩阵的平移部分的负值
|
|
|
|
|
|
|
|
extents = obb_extents
|
|
|
|
processing_log.append(f"OBB计算完成:")
|
|
processing_log.append(f" 中心点: [{obb_center[0]:.6f}, {obb_center[1]:.6f}, {obb_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 = {
|
|
"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:
|
|
# 重新加载原始GLB文件以保持颜色信息
|
|
input_path = self._get_current_input_path()
|
|
original_scene = trimesh.load(input_path)
|
|
|
|
# 提取原始点云数据（保持颜色）
|
|
all_vertices = []
|
|
all_colors = []
|
|
original_point_count = 0
|
|
|
|
if isinstance(original_scene, trimesh.Scene):
|
|
for name, geometry in original_scene.geometry.items():
|
|
if isinstance(geometry, trimesh.PointCloud):
|
|
all_vertices.append(geometry.vertices)
|
|
# 保持原始颜色
|
|
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))
|
|
|
|
# 确保颜色格式一致 (RGBA, 0-255)
|
|
colors = self._normalize_colors(colors)
|
|
all_colors.append(colors)
|
|
original_point_count += len(geometry.vertices)
|
|
processing_log.append(f"保留原始点云: {name}, {len(geometry.vertices):,} 个点，颜色已保持")
|
|
elif hasattr(geometry, 'vertices') and geometry.vertices is not None:
|
|
all_vertices.append(geometry.vertices)
|
|
# 处理可能被转换为Mesh的点云
|
|
if hasattr(geometry.visual, 'vertex_colors') and geometry.visual.vertex_colors is not None:
|
|
colors = geometry.visual.vertex_colors.copy()
|
|
else:
|
|
colors = np.tile([255, 255, 255, 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"保留原始几何体: {name}, {len(geometry.vertices):,} 个点，颜色已保持")
|
|
elif isinstance(original_scene, trimesh.PointCloud):
|
|
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))
|
|
|
|
# 确保颜色格式一致 (RGBA, 0-255)
|
|
colors = self._normalize_colors(colors)
|
|
all_colors.append(colors)
|
|
original_point_count = len(original_scene.vertices)
|
|
processing_log.append(f"保留原始点云: {original_point_count:,} 个点，颜色已保持")
|
|
elif 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([255, 255, 255, 255], (len(original_scene.vertices), 1))
|
|
|
|
# 确保颜色格式一致 (RGBA, 0-255)
|
|
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:
|
|
all_vertices.append(box_vertices)
|
|
all_colors.append(box_colors)
|
|
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:
|
|
all_vertices.append(axes_vertices)
|
|
all_colors.append(axes_colors)
|
|
processing_log.append(f"坐标轴: {len(axes_vertices):,} 个点")
|
|
|
|
# 合并所有点云
|
|
final_vertices = np.vstack(all_vertices)
|
|
final_colors = np.vstack(all_colors)
|
|
|
|
processing_log.append(f"总点数: {len(final_vertices):,} 个点")
|
|
|
|
# 生成输出路径
|
|
output_path = self._generate_output_path(output_filename)
|
|
|
|
# 创建trimesh点云对象
|
|
visualization_pointcloud = trimesh.PointCloud(
|
|
vertices=final_vertices,
|
|
colors=final_colors
|
|
)
|
|
|
|
# 保存为GLB文件
|
|
visualization_pointcloud.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.glb",
|
|
"tooltip": "输出文件名：调整后的点云文件名"
|
|
}),
|
|
}
|
|
}
|
|
|
|
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"):
|
|
"""
|
|
调整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 name, geometry in scene.geometry.items():
|
|
geometries_to_transform.append((name, geometry))
|
|
if hasattr(geometry, 'vertices') and geometry.vertices is not None:
|
|
all_vertices.append(geometry.vertices)
|
|
total_points += len(geometry.vertices)
|
|
processing_log.append(f"发现几何体: {name}, 顶点数: {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}")
|
|
|
|
# 保存变换后的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")
|
|
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 = {
|
|
"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("GLB点云原点调整完成!")
|
|
|
|
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_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([])
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# 节点注册 - 更新注册信息
|
|
# -----------------------------------------------------------------------------
|
|
|
|
NODE_CLASS_MAPPINGS = {
|
|
"GLBPointCloudProcessor": GLBPointCloudProcessor,
|
|
"GLBPointCloudBounds": GLBPointCloudBounds,
|
|
"GLBPointCloudOriginAdjuster": GLBPointCloudOriginAdjuster,
|
|
}
|
|
|
|
NODE_DISPLAY_NAME_MAPPINGS = {
|
|
"GLBPointCloudProcessor": "VVL GLB Point Cloud Processor",
|
|
"GLBPointCloudBounds": "VVL GLB Point Cloud Bounds Visualizer",
|
|
"GLBPointCloudOriginAdjuster": "VVL GLB Point Cloud Origin Adjuster",
|
|
}
|
|
|
|
# # 添加节点信息，帮助ComfyUI更好地识别
|
|
# WEB_DIRECTORY = "./web"
|
|
# __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"] |