如何沿法线（或其反方向）将指定点移动至指定距离？

Got it, let's break down this common 3D geometry task step by step. The goal is to take any point and a normal vector, then shift that point by a set distance either along the normal's direction or its reverse. Here's how to do it properly:

Core Concept #

To move a point consistently along a direction, we need to work with a unit vector (a vector with length 1) so the distance we specify translates directly to how far the point moves. If we use the raw normal vector (which might not be length 1), the point will move by a distance equal to our specified value multiplied by the normal's length—probably not what you want.

Step-by-Step Breakdown #

1. Normalize the Normal Vector #

First, convert your normal into a unit vector by dividing each component by its magnitude (length). For a normal n = (nx, ny, nz), the magnitude is calculated as:

||n|| = sqrt(nx² + ny² + nz²)

The unit normal û is then:

û = (nx/||n||, ny/||n||, nz/||n||)

2. Choose Your Direction #

• To move along the normal's direction, use the unit normal û.
• To move opposite the normal's direction, use -û (multiply each component of û by -1).

3. Calculate the New Point #

Let your original point be P = (px, py, pz) and your desired distance be d. The new point P' is found by adding the scaled direction vector to the original point:

P' = (px + d*ux, py + d*uy, pz + d*uz)

Where (ux, uy, uz) is your chosen direction unit vector.

Example Walkthrough #

Using your provided values:

• Original point: P(1, 1, 0)
• Normal vector: n2(0, 1, 0)
• Desired distance: 3 units, in the reverse direction of the normal.

1. Normalize the normal: The magnitude of n2 is sqrt(0² +1² +0²) = 1, so the unit normal û is (0,1,0).
2. Reverse direction: -û = (0, -1, 0).
3. Compute new point: (1 + 3*0, 1 + 3*(-1), 0 +3*0) = (1, -2, 0).

Code Example (Python) #

Here's a reusable function that handles all cases, including arbitrary points/ normals and direction control:

import math

def move_point_along_normal(point, normal, distance, reverse_direction=False):
    px, py, pz = point
    nx, ny, nz = normal
    
    # Calculate magnitude of the normal vector
    magnitude = math.sqrt(nx**2 + ny**2 + nz**2)
    if magnitude == 0:
        raise ValueError("Normal vector can't be zero-length—no direction to move!")
    
    # Convert to unit vector
    ux = nx / magnitude
    uy = ny / magnitude
    uz = nz / magnitude
    
    # Flip direction if needed
    if reverse_direction:
        ux *= -1
        uy *= -1
        uz *= -1
    
    # Compute and return the new point
    return (
        px + distance * ux,
        py + distance * uy,
        pz + distance * uz
    )

# Test with your example
original_point = (1, 1, 0)
normal = (0, 1, 0)
new_point = move_point_along_normal(original_point, normal, 3, reverse_direction=True)
print(f"New point: {new_point}")  # Output: (1.0, -2.0, 0.0)

Quick Notes #

• If your normal is already a unit vector, you can skip the normalization step to save computation, but including it makes the function robust to any input.
• Alternatively, you can pass a negative distance instead of using the reverse_direction flag—move_point_along_normal(original_point, normal, -3) will give the same result as the example above.

内容的提问来源于stack exchange，提问作者v.slobodzian