如何通过Python在Maya中设置边长度并批量缩放边至指定长度

Hey there! Let's work through your problem step by step. First, I'll fix up that incomplete edge-length code you shared, then show you how to batch-scale selected edges to match your target length, and explain the core logic behind setting edge lengths in Maya with Python.

Step 1: Fix the Target Length Calculation Code #

Your original code was almost there, but it had an incomplete line at the end and lacked some error checking. Here's a polished, working version to get the length of a single selected edge:

import math
import maya.cmds as cmds

def get_single_edge_length():
    # Grab only selected edges (filter out other types)
    selected_edges = cmds.ls(sl=True, fl=True, type='edge')
    
    # Make sure exactly one edge is selected for reference
    if len(selected_edges) != 1:
        cmds.error("Please select exactly ONE edge to use as your target length reference!")
    
    # Convert edge selection to its two vertices
    cmds.ConvertSelectionToVertices()
    verts = cmds.ls(sl=True, fl=True)
    
    # Get world-space positions of the two vertices
    vert_positions = cmds.xform(verts, q=True, t=True, ws=True)
    v1 = (vert_positions[0], vert_positions[1], vert_positions[2])
    v2 = (vert_positions[3], vert_positions[4], vert_positions[5])
    
    # Calculate the Euclidean distance between the two points (edge length)
    edge_length = math.sqrt(
        (v1[0] - v2[0])**2 +
        (v1[1] - v2[1])**2 +
        (v1[2] - v2[2])**2
    )
    
    # Switch back to selecting the original edge
    cmds.select(selected_edges)
    return edge_length

# Get your target length first: select one edge, then run this
target_length = get_single_edge_length()

Step 2: Batch-Scale Edges to Match the Target Length #

Now that we have our target length, here's how to scale any number of selected edges to match it. The logic here is:

1. For each edge, calculate its current length
2. Find the scale ratio needed to reach the target length
3. Scale the edge's vertices outward/inward from the edge's midpoint (so the edge stays centered in its original position)

def scale_edges_to_target(target_length):
    selected_edges = cmds.ls(sl=True, fl=True, type='edge')
    
    if not selected_edges:
        cmds.error("Please select at least one edge to scale!")
    
    for edge in selected_edges:
        # Isolate the current edge and get its vertices
        cmds.select(edge, replace=True)
        cmds.ConvertSelectionToVertices()
        verts = cmds.ls(sl=True, fl=True)
        vert_pos = cmds.xform(verts, q=True, t=True, ws=True)
        
        v1 = (vert_pos[0], vert_pos[1], vert_pos[2])
        v2 = (vert_pos[3], vert_pos[4], vert_pos[5])
        
        # Calculate current length of the edge
        current_length = math.sqrt(
            (v1[0] - v2[0])**2 +
            (v1[1] - v2[1])**2 +
            (v1[2] - v2[2])**2
        )
        
        # Skip edges that have zero length to avoid division errors
        if current_length == 0:
            cmds.warning(f"Skipping edge {edge} - it has zero length!")
            continue
        
        # Calculate how much we need to scale the edge
        scale_ratio = target_length / current_length
        
        # Find the midpoint of the edge (to scale around)
        midpoint = (
            (v1[0] + v2[0])/2,
            (v1[1] + v2[1])/2,
            (v1[2] + v2[2])/2
        )
        
        # Scale each vertex relative to the midpoint
        for idx, vert in enumerate(verts):
            # Get the vertex's position relative to the midpoint
            offset_x = vert_pos[idx*3] - midpoint[0]
            offset_y = vert_pos[idx*3+1] - midpoint[1]
            offset_z = vert_pos[idx*3+2] - midpoint[2]
            
            # Apply the scale to the offset, then calculate new position
            new_x = midpoint[0] + (offset_x * scale_ratio)
            new_y = midpoint[1] + (offset_y * scale_ratio)
            new_z = midpoint[2] + (offset_z * scale_ratio)
            
            # Update the vertex's position
            cmds.xform(vert, ws=True, t=(new_x, new_y, new_z))
    
    # Re-select all the edges we processed
    cmds.select(selected_edges)
    print(f"Successfully scaled {len(selected_edges)} edges to length {target_length}!")

# How to use this:
# 1. Select your reference edge and run target_length = get_single_edge_length()
# 2. Select all edges you want to scale
# 3. Run scale_edges_to_target(target_length)

How Setting Edge Length Works in Maya Python #

Important note: Maya doesn't have a direct "edge length" attribute you can edit. An edge's length is entirely determined by the positions of its two endpoint vertices. So when you want to set an edge's length, you're really adjusting the positions of those two vertices.

There are two common approaches:

1. Scale from midpoint: Like the code above, this keeps the edge centered in its original spot and preserves its direction.
2. Move one vertex: Fix one vertex in place, then move the other along the edge's original direction until the distance matches the target length. Here's a quick example of that:

def set_edge_length_fixed_vertex(edge, target_length):
    cmds.select(edge, replace=True)
    cmds.ConvertSelectionToVertices()
    verts = cmds.ls(sl=True, fl=True)
    
    # Get positions of the two vertices
    v1_pos = cmds.xform(verts[0], q=True, t=True, ws=True)
    v2_pos = cmds.xform(verts[1], q=True, t=True, ws=True)
    
    # Calculate the direction from v1 to v2
    direction = (
        v2_pos[0] - v1_pos[0],
        v2_pos[1] - v1_pos[1],
        v2_pos[2] - v1_pos[2]
    )
    
    # Get the length of the current direction vector
    dir_length = math.sqrt(direction[0]**2 + direction[1]**2 + direction[2]**2)
    if dir_length == 0:
        cmds.warning("Edge has zero length - can't adjust!")
        return
    
    # Normalize the direction vector (make it length 1)
    unit_direction = (
        direction[0]/dir_length,
        direction[1]/dir_length,
        direction[2]/dir_length
    )
    
    # Calculate new position for v2 (keeping v1 fixed)
    new_v2_pos = (
        v1_pos[0] + unit_direction[0] * target_length,
        v1_pos[1] + unit_direction[1] * target_length,
        v1_pos[2] + unit_direction[2] * target_length
    )
    
    # Update v2's position
    cmds.xform(verts[1], ws=True, t=new_v2_pos)

Just remember to always filter your selections to edges (using type='edge') and handle edge cases like zero-length edges to avoid crashes!

内容的提问来源于stack exchange，提问作者dave