n维空间旋转矩阵计算方法及MATLAB实现技术咨询

Great question! You're absolutely right about the 4th condition being redundant—once you have the rotation axis subspace, angle, and a point to rotate, the final position is fully determined (no need to specify it separately). Let's walk through how to build this rotation matrix for any n, plus clarify the uniqueness question.

First: Is the Rotation Matrix Unique? #

Short answer: Almost, but not entirely—though any valid matrix will work for your needs. Here's why:

• The n-2 dimensional rotation axis subspace defines a unique 2-dimensional orthogonal complement (the "rotation plane" where all the rotational action happens).
• If you fix the orientation of this rotation plane (i.e., which direction counts as "positive" θ rotation), the matrix is unique.
• If you don't fix orientation, you'll get two valid matrices: one rotating by θ, the other by -θ (or clockwise vs counterclockwise, though "clockwise" doesn't translate directly to n-dim). Since you said "any is fine", we can just pick a consistent orientation when building the matrix.

Step-by-Step Construction Method #

The core idea is to map the problem to a 2D rotation (which we know how to handle) using an orthogonal basis, then convert back to the original coordinate system.

1. Build an Orthonormal Basis for the Entire Space #

Start with your n-2 unit vectors that span the rotation axis subspace:

• Use the Gram-Schmidt orthogonalization process to turn these vectors into an orthonormal set $u_1, u_2, ..., u_{n-2}$. This ensures they're mutually perpendicular and unit-length.
• Next, find two additional orthonormal vectors $u_{n-1}, u_n$ that are orthogonal to all of the $u_1...u_{n-2}$. These will define your rotation plane.
  • One reliable way is to compute the null space of the matrix formed by $u_1...u_{n-2}$ (the null space contains all vectors orthogonal to the subspace). Take the first two columns of the null space, normalize them, and you're done.
  • Alternatively, generate random vectors, subtract their projections onto the axis subspace and each other, then normalize—this works for most cases.

2. Define the Rotation in the New Basis #

Create a block-diagonal matrix $R'$ in the basis ${u_1, u_2, ..., u_n}$:

• The first n-2 diagonal entries are 1 (vectors in the rotation axis subspace don't move during rotation).
• The final 2x2 block is the standard 2D rotation matrix:

  [cosθ  -sinθ]
  [sinθ   cosθ]
  

  (Flip the sin signs if you want the opposite rotation direction—again, either works for your use case.)

3. Convert Back to the Original Coordinate System #

Let $U$ be the orthogonal matrix whose columns are the basis vectors $u_1...u_n$. Since $U$ is orthonormal, its inverse is just its transpose ($U^{-1} = U^T$).

The rotation matrix in your original coordinate system is:
$$R = U R' U^T$$

Example Pseudocode (Python/Numpy) #

Here's a rough implementation to illustrate the steps:

import numpy as np

def build_n_dim_rot_matrix(axis_vectors, theta):
    # axis_vectors: (n-2) x n array, each row is a unit vector spanning the rotation axis
    n = axis_vectors.shape[1]
    num_axis_vecs = axis_vectors.shape[0]  # should be n-2

    # Step 1: Orthogonalize axis vectors with Gram-Schmidt
    ortho_axis = []
    for vec in axis_vectors:
        v = vec.copy()
        for u in ortho_axis:
            v -= np.dot(v, u) * u
        v /= np.linalg.norm(v)
        ortho_axis.append(v)
    ortho_axis = np.array(ortho_axis)

    # Step 1b: Find orthonormal vectors for the rotation plane
    null_space = np.linalg.null_space(ortho_axis)
    u_rot1 = null_space[:, 0] / np.linalg.norm(null_space[:, 0])
    u_rot2 = null_space[:, 1] / np.linalg.norm(null_space[:, 1])

    # Build orthonormal basis matrix U (columns are basis vectors)
    U = np.hstack([ortho_axis.T, u_rot1.reshape(-1,1), u_rot2.reshape(-1,1)])

    # Step 2: Build R' (rotation in the new basis)
    R_prime = np.eye(n)
    R_prime[-2:, -2:] = np.array([
        [np.cos(theta), -np.sin(theta)],
        [np.sin(theta), np.cos(theta)]
    ])

    # Step 3: Convert to original basis
    R = U @ R_prime @ U.T

    # Ensure numerical stability (fix tiny errors from floating point)
    R = np.round(R, 12)
    return R

Why This Works #

• $R$ is an orthogonal matrix ($R^T R = I$), which is required for rotations (they preserve lengths and angles).
• $\det(R) = 1$, meaning it's a proper rotation (no reflection).
• Any vector in the original rotation axis subspace will be unchanged by $R$, and vectors in the rotation plane will be rotated by θ.

For the 3D case (n=3), this exactly matches what vrrotvec2mat does—since the rotation axis is 1D, the orthogonal complement is the 2D rotation plane, and the math simplifies to the familiar 3D rotation matrix formula.

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