The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
add VoxelToMesh node w/ surfacenet meshing (#7446)
thot experimentfe29739c6858
diff --git a/comfy_extras/nodes_hunyuan3d.py b/comfy_extras/nodes_hunyuan3d.pyindex 5adc6b654..30cbd06da 100644--- a/comfy_extras/nodes_hunyuan3d.py+++ b/comfy_extras/nodes_hunyuan3d.py@@ -209,6 +209,196 @@ def voxel_to_mesh(voxels, threshold=0.5, device=None):vertices = torch.fliplr(vertices)return vertices, faces+def voxel_to_mesh_surfnet(voxels, threshold=0.5, device=None):+ if device is None:+ device = torch.device("cpu")+ voxels = voxels.to(device)++ D, H, W = voxels.shape++ padded = torch.nn.functional.pad(voxels, (1, 1, 1, 1, 1, 1), 'constant', 0)+ z, y, x = torch.meshgrid(+ torch.arange(D, device=device),+ torch.arange(H, device=device),+ torch.arange(W, device=device),+ indexing='ij'+ )+ cell_positions = torch.stack([z.flatten(), y.flatten(), x.flatten()], dim=1)++ corner_offsets = torch.tensor([+ [0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0],+ [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]+ ], device=device)++ corner_values = torch.zeros((cell_positions.shape[0], 8), device=device)+ for c, (dz, dy, dx) in enumerate(corner_offsets):+ corner_values[:, c] = padded[+ cell_positions[:, 0] + dz,+ cell_positions[:, 1] + dy,+ cell_positions[:, 2] + dx+ ]++ corner_signs = corner_values > threshold+ has_inside = torch.any(corner_signs, dim=1)+ has_outside = torch.any(~corner_signs, dim=1)+ contains_surface = has_inside & has_outside++ active_cells = cell_positions[contains_surface]+ active_signs = corner_signs[contains_surface]+ active_values = corner_values[contains_surface]++ if active_cells.shape[0] == 0:+ return torch.zeros((0, 3), device=device), torch.zeros((0, 3), dtype=torch.long, device=device)++ edges = torch.tensor([+ [0, 1], [0, 2], [0, 4], [1, 3],+ [1, 5], [2, 3], [2, 6], [3, 7],+ [4, 5], [4, 6], [5, 7], [6, 7]+ ], device=device)++ cell_vertices = {}+ progress = comfy.utils.ProgressBar(100)++ for edge_idx, (e1, e2) in enumerate(edges):+ progress.update(1)+ crossing = active_signs[:, e1] != active_signs[:, e2]+ if not crossing.any():+ continue++ cell_indices = torch.nonzero(crossing, as_tuple=True)[0]++ v1 = active_values[cell_indices, e1]+ v2 = active_values[cell_indices, e2]++ t = torch.zeros_like(v1, device=device)+ denom = v2 - v1+ valid = denom != 0+ t[valid] = (threshold - v1[valid]) / denom[valid]+ t[~valid] = 0.5++ p1 = corner_offsets[e1].float()+ p2 = corner_offsets[e2].float()++ intersection = p1.unsqueeze(0) + t.unsqueeze(1) * (p2.unsqueeze(0) - p1.unsqueeze(0))++ for i, point in zip(cell_indices.tolist(), intersection):+ if i not in cell_vertices:+ cell_vertices[i] = []+ cell_vertices[i].append(point)++ # Calculate the final vertices as the average of intersection points for each cell+ vertices = []+ vertex_lookup = {}++ vert_progress_mod = round(len(cell_vertices)/50)++ for i, points in cell_vertices.items():+ if not i % vert_progress_mod:+ progress.update(1)++ if points:+ vertex = torch.stack(points).mean(dim=0)+ vertex = vertex + active_cells[i].float()+ vertex_lookup[tuple(active_cells[i].tolist())] = len(vertices)+ vertices.append(vertex)++ if not vertices:+ return torch.zeros((0, 3), device=device), torch.zeros((0, 3), dtype=torch.long, device=device)++ final_vertices = torch.stack(vertices)++ inside_corners_mask = active_signs+ outside_corners_mask = ~active_signs++ inside_counts = inside_corners_mask.sum(dim=1, keepdim=True).float()+ outside_counts = outside_corners_mask.sum(dim=1, keepdim=True).float()++ inside_pos = torch.zeros((active_cells.shape[0], 3), device=device)+ outside_pos = torch.zeros((active_cells.shape[0], 3), device=device)++ for i in range(8):+ mask_inside = inside_corners_mask[:, i].unsqueeze(1)+ mask_outside = outside_corners_mask[:, i].unsqueeze(1)+ inside_pos += corner_offsets[i].float().unsqueeze(0) * mask_inside+ outside_pos += corner_offsets[i].float().unsqueeze(0) * mask_outside++ inside_pos /= inside_counts+ outside_pos /= outside_counts+ gradients = inside_pos - outside_pos++ pos_dirs = torch.tensor([+ [1, 0, 0],+ [0, 1, 0],+ [0, 0, 1]+ ], device=device)++ cross_products = [+ torch.linalg.cross(pos_dirs[i].float(), pos_dirs[j].float())+ for i in range(3) for j in range(i+1, 3)+ ]++ faces = []+ all_keys = set(vertex_lookup.keys())++ face_progress_mod = round(len(active_cells)/38*3)++ for pair_idx, (i, j) in enumerate([(0,1), (0,2), (1,2)]):+ dir_i = pos_dirs[i]+ dir_j = pos_dirs[j]+ cross_product = cross_products[pair_idx]++ ni_positions = active_cells + dir_i+ nj_positions = active_cells + dir_j+ diag_positions = active_cells + dir_i + dir_j++ alignments = torch.matmul(gradients, cross_product)++ valid_quads = []+ quad_indices = []++ for idx, active_cell in enumerate(active_cells):+ if not idx % face_progress_mod:+ progress.update(1)+ cell_key = tuple(active_cell.tolist())+ ni_key = tuple(ni_positions[idx].tolist())+ nj_key = tuple(nj_positions[idx].tolist())+ diag_key = tuple(diag_positions[idx].tolist())++ if cell_key in all_keys and ni_key in all_keys and nj_key in all_keys and diag_key in all_keys:+ v0 = vertex_lookup[cell_key]+ v1 = vertex_lookup[ni_key]+ v2 = vertex_lookup[nj_key]+ v3 = vertex_lookup[diag_key]++ valid_quads.append((v0, v1, v2, v3))+ quad_indices.append(idx)++ for q_idx, (v0, v1, v2, v3) in enumerate(valid_quads):+ cell_idx = quad_indices[q_idx]+ if alignments[cell_idx] > 0:+ faces.append(torch.tensor([v0, v1, v3], device=device, dtype=torch.long))+ faces.append(torch.tensor([v0, v3, v2], device=device, dtype=torch.long))+ else:+ faces.append(torch.tensor([v0, v3, v1], device=device, dtype=torch.long))+ faces.append(torch.tensor([v0, v2, v3], device=device, dtype=torch.long))++ if faces:+ faces = torch.stack(faces)+ else:+ faces = torch.zeros((0, 3), dtype=torch.long, device=device)++ v_min = 0+ v_max = max(D, H, W)++ final_vertices = final_vertices - (v_min + v_max) / 2++ scale = (v_max - v_min) / 2+ if scale > 0:+ final_vertices = final_vertices / scale++ final_vertices = torch.fliplr(final_vertices)++ return final_vertices, facesclass MESH:def __init__(self, vertices, faces):@@ -237,6 +427,34 @@ class VoxelToMeshBasic:return (MESH(torch.stack(vertices), torch.stack(faces)), )+class VoxelToMesh:+ @classmethod+ def INPUT_TYPES(s):+ return {"required": {"voxel": ("VOXEL", ),+ "algorithm": (["basic", "surface net"], ),+ "threshold": ("FLOAT", {"default": 0.6, "min": -1.0, "max": 1.0, "step": 0.01}),+ }}+ RETURN_TYPES = ("MESH",)+ FUNCTION = "decode"++ CATEGORY = "3d"++ def decode(self, voxel, algorithm, threshold):+ vertices = []+ faces = []++ if algorithm == "basic":+ mesh_function = voxel_to_mesh+ elif algorithm == "surface net":+ mesh_function = voxel_to_mesh_surfnet++ for x in voxel.data:+ v, f = mesh_function(x, threshold=threshold, device=None)+ vertices.append(v)+ faces.append(f)++ return (MESH(torch.stack(vertices), torch.stack(faces)), )+def save_glb(vertices, faces, filepath, metadata=None):"""@@ -411,5 +629,6 @@ NODE_CLASS_MAPPINGS = {"Hunyuan3Dv2ConditioningMultiView": Hunyuan3Dv2ConditioningMultiView,"VAEDecodeHunyuan3D": VAEDecodeHunyuan3D,"VoxelToMeshBasic": VoxelToMeshBasic,+ "VoxelToMesh": VoxelToMesh,"SaveGLB": SaveGLB,}