diff options
| -rw-r--r-- | Scripts/BakeVertexData.py | 392 |
1 files changed, 82 insertions, 310 deletions
diff --git a/Scripts/BakeVertexData.py b/Scripts/BakeVertexData.py index 1f11e06..efc1f2e 100644 --- a/Scripts/BakeVertexData.py +++ b/Scripts/BakeVertexData.py @@ -1061,8 +1061,6 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi precision=3 ) - - def build_face_spatial_cache(self, bm, selected_faces): """Build spatial cache for fast proximity queries""" face_centers = {} @@ -1098,28 +1096,21 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi def build_combined_adjacency(self, bm, selected_faces, face_centers, face_bounds): """Build adjacency including both edge connections and spatial proximity""" - import time angle_threshold_cos = math.cos(self.angle_threshold) gap_dist_sq = self.gap_distance * self.gap_distance # Build edge-based adjacency - edge_start = time.time() edge_adjacency = defaultdict(set) - selected_set = set(selected_faces) # Convert to set for O(1) lookup + selected_set = set(selected_faces) for edge in bm.edges: if len(edge.link_faces) == 2: f1, f2 = edge.link_faces if f1.index in selected_set and f2.index in selected_set: - # For edge connections, always connect if they share an edge - # The angle threshold will be applied during island grouping edge_adjacency[f1.index].add(f2.index) edge_adjacency[f2.index].add(f1.index) - print(f" Edge adjacency took {time.time() - edge_start:.3f}s") - # Build spatial grid for efficient proximity queries - grid_start = time.time() grid_size = max(self.gap_distance * 2, 0.01) spatial_grid = defaultdict(list) @@ -1142,11 +1133,8 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi ) spatial_grid[neighbor_key].append(face_idx) - print(f" Spatial grid took {time.time() - grid_start:.3f}s") - - # Only build proximity adjacency if gap distance is significant + # Build proximity adjacency if gap distance is significant proximity_adjacency = defaultdict(set) - proximity_start = time.time() if self.gap_distance > 0.0001: # Build face-to-vertex mapping with spatial hashing @@ -1154,7 +1142,6 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi for face_idx in selected_faces: face = bm.faces[face_idx] - # Add face to grid cells of all its vertices for vert in face.verts: v_key = ( int(vert.co.x / grid_size), @@ -1190,7 +1177,6 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi neighbor_key = (v_key[0] + dx, v_key[1] + dy, v_key[2] + dz) candidates.update(face_vertex_grid.get(neighbor_key, set())) - # Remove self candidates.discard(face_idx) # Check each candidate @@ -1236,8 +1222,6 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi proximity_adjacency[face_idx].add(other_idx) proximity_adjacency[other_idx].add(face_idx) - print(f" Proximity adjacency took {time.time() - proximity_start:.3f}s") - # Combine adjacencies - ensure ALL selected faces are in the result combined = defaultdict(set) @@ -1348,11 +1332,9 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi projected_uvs = {} min_uv = mathutils.Vector((float('inf'), float('inf'))) max_uv = mathutils.Vector((float('-inf'), float('-inf'))) - loop_count = 0 for face_idx in face_group: if face_idx >= len(bm.faces): - print(f" Warning: Invalid face index {face_idx}") continue face = bm.faces[face_idx] @@ -1366,284 +1348,143 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi min_uv.y = min(min_uv.y, uv.y) max_uv.x = max(max_uv.x, uv.x) max_uv.y = max(max_uv.y, uv.y) - loop_count += 1 if not projected_uvs: - print(f" Warning: No UVs projected for group with {len(face_group)} faces") return None size = max_uv - min_uv if size.x <= 0 or size.y <= 0: - print(f" Warning: Invalid UV size: {size} for group with {len(face_group)} faces") return None - # Add some validation - if size.x > 1000 or size.y > 1000: - print(f" Warning: Extremely large UV size: {size} - this might indicate a projection issue") - return { 'min_uv': min_uv, 'max_uv': max_uv, 'size': size, 'projected_uvs': projected_uvs, 'face_count': len(face_group), - 'loop_count': loop_count, - 'face_indices': face_group # Store face indices for 3D area calculation + 'face_indices': face_group } def pack_uv_islands_growing(self, islands, bm, uv_layer): - """Pack UV islands using an improved bin packing algorithm with uniform texel density""" + """Pack UV islands using shelf packing with uniform texel density + + Algorithm: + 1. Calculates a uniform scale factor based on 3D surface area to normalize texel density + 2. Sorts islands by height (tallest first) for efficient shelf packing + 3. Places islands on horizontal shelves with smart height matching (50%-200% tolerance) + 4. Maintains consistent margins between islands + 5. Scales result to fit within UV space (0-1 range) + + This produces approximately square UV layouts even with significant padding. + """ import math if not islands: - print("UV Packing: No islands to pack") return - # Filter valid islands and calculate areas + # Filter valid islands and calculate 3D surface area valid_islands = [] - island_areas = [] total_3d_area = 0.0 - total_uv_area = 0.0 - - for i, island in enumerate(islands): - if island is not None: - uv_area = island['size'].x * island['size'].y - if uv_area > 0: - # Calculate 3D surface area for this island - surface_area_3d = 0.0 - for face_idx in island.get('face_indices', []): - if face_idx < len(bm.faces): - surface_area_3d += bm.faces[face_idx].calc_area() - - # Store both UV and 3D areas - island['uv_area'] = uv_area - island['surface_area_3d'] = surface_area_3d - total_3d_area += surface_area_3d - total_uv_area += uv_area - - valid_islands.append(island) - island_areas.append(uv_area) + + for island in islands: + if island and island['size'].x > 0 and island['size'].y > 0: + # Calculate 3D surface area for this island + surface_area_3d = sum( + bm.faces[face_idx].calc_area() + for face_idx in island.get('face_indices', []) + if face_idx < len(bm.faces) + ) + + island['surface_area_3d'] = surface_area_3d + total_3d_area += surface_area_3d + valid_islands.append(island) if not valid_islands: - print("UV Packing: No valid islands after filtering") return - # Calculate uniform texel density scale - # The goal is to make UV area proportional to 3D surface area - target_total_uv_area = 0.8 # Use 80% of UV space to leave room for margins - - # Calculate the scale needed to achieve uniform texel density - uniform_scale = 1.0 - if total_3d_area > 0: - # Direct calculation: total UV area should equal target area - # Each island's UV size should be proportional to sqrt(3D area) - uniform_scale = math.sqrt(target_total_uv_area / total_3d_area) - - print(f"\nUV Packing Statistics:") - print(f" Total islands: {len(valid_islands)}") - print(f" Total 3D surface area: {total_3d_area:.6f}") - print(f" Uniform texel density scale: {uniform_scale:.3f}") - - # Create histogram of island sizes (logarithmic bins) - if island_areas: - min_area = min(island_areas) - max_area = max(island_areas) - print(f" UV area range: {min_area:.6f} to {max_area:.6f}") - - if min_area > 0 and max_area > min_area: - log_min = math.log10(min_area) - log_max = math.log10(max_area) - num_bins = min(10, len(valid_islands)) - - if log_max - log_min > 0.01: - bins = [0] * num_bins - bin_edges = [] - - for i in range(num_bins + 1): - edge = log_min + (log_max - log_min) * i / num_bins - bin_edges.append(10 ** edge) - - for area in island_areas: - for i in range(num_bins): - if bin_edges[i] <= area < bin_edges[i + 1]: - bins[i] += 1 - break - else: - bins[-1] += 1 - - print("\n Island size histogram (logarithmic):") - for i in range(num_bins): - print(f" [{bin_edges[i]:.6f} - {bin_edges[i+1]:.6f}): {bins[i]} islands") + # Calculate uniform scale to normalize texel density + target_coverage = 0.8 # Use 80% of UV space + uniform_scale = math.sqrt(target_coverage / total_3d_area) if total_3d_area > 0 else 1.0 # Apply uniform scale to all islands for island in valid_islands: - island['uniform_scale'] = uniform_scale - island['scaled_size'] = mathutils.Vector(( - island['size'].x * uniform_scale, - island['size'].y * uniform_scale - )) - - # Sort by height (tallest first) for better shelf packing - indexed_islands = [(i, island, island['scaled_size'].y) + island['scaled_size'] = island['size'] * uniform_scale - for i, island in enumerate(valid_islands)] - indexed_islands.sort(key=lambda x: x[2], reverse=True) + # Sort by height (tallest first) for shelf packing + valid_islands.sort(key=lambda x: x['scaled_size'].y, reverse=True) - # Debug: track pack order - pack_order = [] + # Estimate target width for approximately square packing + total_area = sum(island['scaled_size'].x * island['scaled_size'].y for island in valid_islands) - # Use simple shelf packing with better space utilization - shelves = [] - packed_count = 0 - - # Calculate total area to determine target width for square packing - total_area = 0.0 - for island in valid_islands: - width = island['scaled_size'].x + self.island_margin - height = island['scaled_size'].y + self.island_margin - total_area += width * height + # Estimate margin overhead: roughly sqrt(n) gaps horizontally and vertically + n_islands = len(valid_islands) + estimated_gaps = 2 * math.sqrt(n_islands) + estimated_margin_area = estimated_gaps * self.island_margin * math.sqrt(total_area) - # Target width for approximately square result - target_width = math.sqrt(total_area) * 1.1 # Add 10% for inefficiency + # Calculate target width from total area including margins + total_area_with_margins = total_area + estimated_margin_area + target_width = math.sqrt(total_area_with_margins) * 1.1 # 10% safety factor - # Width-constrained shelf packing + # Shelf packing shelves = [] - packed_count = 0 current_y = self.island_margin - # Pack islands - for idx, (original_idx, island, sort_height) in enumerate(indexed_islands): - width = island['scaled_size'].x + self.island_margin - height = island['scaled_size'].y + self.island_margin - - # Skip if island is wider than target - if width > target_width: - print(f" Warning: Island {original_idx} width {width:.3f} exceeds target {target_width:.3f}") - target_width = width + self.island_margin + for island in valid_islands: + width = island['scaled_size'].x + height = island['scaled_size'].y - # Find shelf with space + # Find a suitable shelf placed = False - for shelf_idx, shelf in enumerate(shelves): - if shelf['remaining_width'] >= width: - # Height compatibility check - height_ratio = height / shelf['height'] if shelf['height'] > 0 else float('inf') - if 0.7 <= height_ratio <= 1.3: # Allow 30% height variation + for shelf in shelves: + # Check horizontal space + if shelf['current_x'] + self.island_margin + width <= target_width - self.island_margin: + # Check height compatibility (50% to 200% of shelf height) + height_ratio = height / shelf['height'] + if 0.5 <= height_ratio <= 2.0: # Place on this shelf - island['pack_position'] = mathutils.Vector((shelf['current_x'], shelf['y_position'])) - - if idx < 5: # Debug first few - print(f" Island {idx} placed on shelf {shelf_idx} at ({shelf['current_x']:.3f}, {shelf['y_position']:.3f})") - - shelf['current_x'] += width - shelf['remaining_width'] -= width - packed_count += 1 + island['pack_position'] = mathutils.Vector(( + shelf['current_x'] + self.island_margin, + shelf['y_position'] + )) + shelf['current_x'] += self.island_margin + width placed = True - pack_order.append((original_idx, island['pack_position'].copy())) break if not placed: # Create new shelf - new_shelf = { + island['pack_position'] = mathutils.Vector((self.island_margin, current_y)) + shelves.append({ 'y_position': current_y, 'height': height, - 'current_x': width, # Start after this island - 'remaining_width': target_width - width, - } - shelves.append(new_shelf) - - island['pack_position'] = mathutils.Vector((0, current_y)) - - if idx < 5: # Debug first few - print(f" Island {idx} created new shelf at y={current_y:.3f}") - - current_y += height - packed_count += 1 - pack_order.append((original_idx, island['pack_position'].copy())) - - # Calculate final dimensions - max_x = target_width - max_y = current_y - - print(f"\n Packed {packed_count} islands with uniform texel density") - print(f" Created {len(shelves)} shelves with target width {target_width:.3f}") - - # Calculate packing results - if packed_count > 0: - # Calculate efficiency - total_island_area = sum(island['scaled_size'].x * island['scaled_size'].y - for island in valid_islands) - total_used_area = max_x * max_y - efficiency = total_island_area / total_used_area if total_used_area > 0 else 0 - - aspect_ratio = max_x / max_y if max_y > 0 else 1.0 - - print(f" Pack dimensions: {max_x:.3f} x {max_y:.3f}") - print(f" Aspect ratio: {aspect_ratio:.2f} (1.0 = perfect square)") - print(f" Packing efficiency: {efficiency:.1%}") - - # Scale to fit in UV space - scale_factor = min(0.95 / max_x, 0.95 / max_y) if max(max_x, max_y) > 0 else 1.0 - - # Apply scale to all positions - for island in valid_islands: - if 'pack_position' in island: - island['pack_position'] *= scale_factor - - total_height = max_y * scale_factor - final_scale = scale_factor - else: - total_height = 0 - final_scale = 1.0 + 'current_x': self.island_margin + width + }) + current_y += height + self.island_margin - if total_height > 0.95: - print(f" Warning: Not enough UV space for desired texel density. Consider increasing angle threshold.") + # Calculate final dimensions and scale to fit UV space + pack_width = max(target_width, max(shelf['current_x'] + self.island_margin for shelf in shelves)) + pack_height = current_y + scale_factor = min(0.98 / pack_width, 0.98 / pack_height) - # Apply UV coordinates with uniform texel density - applied_count = 0 - debug_islands = 0 + # Apply UV coordinates for island in valid_islands: if 'pack_position' not in island: - print(f" Warning: Island without pack position!") continue - # Get the scale needed to match packed size - position = island['pack_position'] * final_scale - # Scale to match the packed size (which includes uniform scale) - size_scale = island['uniform_scale'] * final_scale + position = island['pack_position'] * scale_factor + size_scale = uniform_scale * scale_factor min_uv = island['min_uv'] - # Debug first few islands - if debug_islands < 3: - expected_size = island['size'] * size_scale - print(f"\n Debug island {debug_islands}:") - print(f" Original size: {island['size']}") - print(f" Scaled size: {island['scaled_size']}") - print(f" Pack position: {island['pack_position']}") - print(f" Final position: {position}") - print(f" Size scale: {size_scale:.4f}") - print(f" Expected final size: {expected_size}") - debug_islands += 1 - # Apply to all loops for loop, original_uv in island['projected_uvs'].items(): - # Scale and translate the UV new_uv = (original_uv - min_uv) * size_scale + position loop[uv_layer].uv = new_uv - applied_count += 1 - print(f" Applied UVs to {applied_count} loops") - print(f" Final UV space usage: {min(max_y * final_scale, 1.0):.1%}") - print(f" Final texel density scale: {uniform_scale * final_scale:.4f}") + # Report results + efficiency = total_area / (pack_width * pack_height) if pack_height > 0 else 0 + aspect_ratio = pack_width / pack_height if pack_height > 0 else 1.0 - # Debug: print first few islands in pack order - if pack_order: - print("\n First 5 islands in pack order:") - for i in range(min(5, len(pack_order))): - original_idx, position = pack_order[i] - island = indexed_islands[i][1] # Get the island from sorted list - print(f" Pack order {i}: orig_idx={original_idx}, size={island['scaled_size']}, pos={position}") - - print("") # Empty line for readability + print(f"\n Packed {len(valid_islands)} UV islands") + print(f" Shelves: {len(shelves)}, Aspect ratio: {aspect_ratio:.2f}, Efficiency: {efficiency:.0%}") def process_object(self, context, obj): import time @@ -1657,7 +1498,6 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi # Get or create UV layer if not bm.loops.layers.uv: bm.loops.layers.uv.new("UVMap") - print(" Created new UV layer") uv_layer = bm.loops.layers.uv.active if not uv_layer: @@ -1665,115 +1505,47 @@ class MESH_OT_smart_uv_project_normal_groups(BaseSubmeshOperator, UVOperatorMixi return False, {} # Get selected faces - t1 = time.time() - selected_faces = [] - for face in bm.faces: - if face.select and not face.hide: - selected_faces.append(face.index) + selected_faces = [face.index for face in bm.faces if face.select and not face.hide] - print(f" Selected faces: {len(selected_faces)} (took {time.time()-t1:.3f}s)") + print(f" Selected faces: {len(selected_faces)}") if not selected_faces: return False, {} # Build spatial cache - t2 = time.time() face_centers, face_bounds = self.build_face_spatial_cache(bm, selected_faces) - print(f" Built spatial cache for {len(face_centers)} faces (took {time.time()-t2:.3f}s)") # Build combined adjacency - t3 = time.time() adjacency = self.build_combined_adjacency(bm, selected_faces, face_centers, face_bounds) - print(f" Built adjacency (took {time.time()-t3:.3f}s)") - - # Count adjacency connections - t4 = time.time() - edge_connections = 0 - proximity_connections = 0 - isolated_faces = 0 - - for face_idx in selected_faces: - neighbors = adjacency.get(face_idx, set()) - if not neighbors: - isolated_faces += 1 - - for neighbor in neighbors: - # Check if they share an edge - face = bm.faces[face_idx] - neighbor_face = bm.faces[neighbor] - shares_edge = False - for edge in face.edges: - if edge in neighbor_face.edges: - shares_edge = True - break - if shares_edge: - edge_connections += 1 - else: - proximity_connections += 1 - - print(f" Adjacency stats: {edge_connections//2} edge connections, {proximity_connections//2} proximity connections, {isolated_faces} isolated faces") - print(f" (adjacency analysis took {time.time()-t4:.3f}s)") - - # Debug: print some adjacency info - if len(selected_faces) > 0: - sample_face = selected_faces[0] - print(f" Debug - Face {sample_face} has {len(adjacency.get(sample_face, set()))} neighbors") # Find face groups using flood fill - t5 = time.time() face_groups = self.find_face_groups_flood_fill(selected_faces, adjacency, bm) - print(f" Found {len(face_groups)} face groups (took {time.time()-t5:.3f}s)") - - if face_groups: - group_sizes = [len(g) for g in face_groups] - print(f" Group sizes: min={min(group_sizes)}, max={max(group_sizes)}, avg={sum(group_sizes)/len(group_sizes):.1f}") + print(f" Found {len(face_groups)} face groups") if not face_groups: return False, {} # Process each group - t6 = time.time() islands = [] processed_faces = 0 - failed_projections = 0 - - # Only show warnings for first few failures - max_warnings = 5 - warning_count = 0 - for i, group in enumerate(face_groups): + for group in face_groups: projection_matrix, center = self.calculate_projection_matrix(group, bm) if projection_matrix is not None: island_data = self.project_faces_to_uv(group, projection_matrix, center, bm, uv_layer) if island_data: islands.append(island_data) processed_faces += island_data['face_count'] - else: - failed_projections += 1 - if warning_count < max_warnings: - print(f" Warning: Failed to project group {i} with {len(group)} faces") - warning_count += 1 - else: - failed_projections += 1 - if warning_count < max_warnings: - print(f" Warning: Failed to calculate projection for group {i} with {len(group)} faces") - warning_count += 1 - print(f" Created {len(islands)} UV islands from {len(face_groups)} groups (took {time.time()-t6:.3f}s)") - if failed_projections > 0: - print(f" Failed projections: {failed_projections}") + print(f" Created {len(islands)} UV islands") # Pack islands - t7 = time.time() if islands: self.pack_uv_islands_growing(islands, bm, uv_layer) - print(f" Packing completed (took {time.time()-t7:.3f}s)") - else: - print(" ERROR: No islands to pack!") bmesh.update_edit_mesh(obj.data) - print(f" Total processing time: {time.time()-start_time:.3f}s") + print(f" Total time: {time.time()-start_time:.2f}s") return True, { 'groups': len(face_groups), |