# klampt.math.so3 module

Operations for rigid rotations in Klampt. All rotations are represented by a 9-list specifying the entries of the rotation matrix in column major form.

In other words, given a 3x3 matrix:

```[a11,a12,a13]
[a21,a22,a23]
[a31,a32,a33],
```

Klamp’t represents the matrix as a list [a11,a21,a31,a12,a22,a32,a13,a23,a33].

The reasons for this representation are 1) simplicity, and 2) a more convenient interface with C code.

klampt.math.so3.identity()[source]

Returns the identity rotation.

Return type:

`Sequence`[`float`]

klampt.math.so3.inv(R)[source]

Inverts the rotation.

Return type:

`Sequence`[`float`]

klampt.math.so3.apply(R, point)[source]

Applies the rotation to a point.

Return type:

`Sequence`[`float`]

klampt.math.so3.matrix(R)[source]

Returns the 3x3 rotation matrix corresponding to R.

Return type:

`Sequence`[`Sequence`[`float`]]

klampt.math.so3.from_matrix(mat)[source]

Returns a rotation R corresponding to the 3x3 rotation matrix mat.

Return type:

`Sequence`[`float`]

klampt.math.so3.ndarray(R)[source]

Returns the 3x3 numpy rotation matrix corresponding to R.

Return type:

`ndarray`

klampt.math.so3.from_ndarray(mat)[source]

Returns a rotation R corresponding to the 3x3 rotation matrix mat.

Return type:

`Sequence`[`float`]

klampt.math.so3.mul(R1, R2)[source]

Multiplies two rotations.

Return type:

`Sequence`[`float`]

klampt.math.so3.trace(R)[source]

Computes the trace of the rotation matrix.

Return type:

`float`

klampt.math.so3.angle(R)[source]

Returns absolute deviation of R from identity

Return type:

`float`

klampt.math.so3.rpy(R)[source]

Converts a rotation matrix to a roll,pitch,yaw angle triple. The result is given in radians.

Return type:

`Sequence`[`float`]

klampt.math.so3.from_rpy(rollpitchyaw)[source]

Converts from roll,pitch,yaw angle triple to a rotation matrix. The triple is given in radians. The x axis is “roll”, y is “pitch”, and z is “yaw”.

Return type:

`Sequence`[`float`]

klampt.math.so3.rotation_vector(R)[source]

Returns the rotation vector w (exponential map) representation of R such that e^[w] = R. Equivalent to axis-angle representation with w/||w||=axis, ||w||=angle.

Return type:

`Sequence`[`float`]

klampt.math.so3.axis_angle(R)[source]

Returns the (axis,angle) pair representing R

Return type:

`Tuple`

klampt.math.so3.from_axis_angle(aa)[source]

Converts an axis-angle representation (axis,angle) to a 3D rotation matrix.

Return type:

`Sequence`[`float`]

klampt.math.so3.from_rotation_vector(w)[source]

Converts a rotation vector representation w to a 3D rotation matrix.

Return type:

`Sequence`[`float`]

klampt.math.so3.moment(R)

Returns the rotation vector w (exponential map) representation of R such that e^[w] = R. Equivalent to axis-angle representation with w/||w||=axis, ||w||=angle.

Return type:

`Sequence`[`float`]

klampt.math.so3.from_moment(w)

Converts a rotation vector representation w to a 3D rotation matrix.

Return type:

`Sequence`[`float`]

klampt.math.so3.from_quaternion(q)[source]

Given a unit quaternion (w,x,y,z), produce the corresponding rotation matrix.

Return type:

`Sequence`[`float`]

klampt.math.so3.quaternion(R)[source]

Given a Klamp’t rotation representation, produces the corresponding unit quaternion (w,x,y,z).

Return type:

`Tuple`

klampt.math.so3.distance(R1, R2)[source]

Returns the absolute angle one would need to rotate in order to get from R1 to R2

Return type:

`float`

klampt.math.so3.error(R1, R2)[source]

Returns a 3D “difference vector” that describes how far R1 is from R2. More precisely, this is the (local) Lie derivative, which is the rotation vector representation of R1*R2^T.

Fun fact: the error w=error(R1,R2) is related to the derivative of interpolate(R2,R1,u) at u=0 by d/du interpolate(R2,R1,0) = mul(cross_product(w),R2).

You can also recover R1 from w via R1 = mul(from_moment(w),R2).

Return type:

`float`

klampt.math.so3.cross_product(w)[source]

Returns the cross product matrix associated with w.

The matrix [w]R is the derivative of the matrix R as it rotates about the axis w/||w|| with angular velocity ||w||.

Return type:

`Sequence`[`float`]

klampt.math.so3.diag(R)[source]

Returns the diagonal of the 3x3 matrix reprsenting the so3 element R.

Return type:

`Sequence`[`float`]

klampt.math.so3.deskew(R)[source]

If R is a (flattened) cross-product matrix of the 3-vector w, this will return w. Otherwise, it will return a representation w of (R-R^T)/2 (off diagonals of R) such that (R-R^T)/2 = cross_product(w).

Return type:

`Sequence`[`float`]

klampt.math.so3.rotation(axis, angle)[source]

Given a unit axis and an angle in radians, returns the rotation matrix.

Return type:

`Sequence`[`float`]

klampt.math.so3.canonical(v)[source]

Given a unit vector v, finds R that defines a basis [x,y,z] such that x = v and y and z are orthogonal

Return type:

`Sequence`[`float`]

klampt.math.so3.align(a, b)[source]

Returns a minimal-angle rotation that aligns the vector a to align with the vector b. Both a and b must be nonzero.

Return type:

`Sequence`[`float`]

klampt.math.so3.interpolate(R1, R2, u)[source]

Interpolate linearly between the two rotations R1 and R2.

Return type:

`Sequence`[`float`]

klampt.math.so3.interpolator(R1, R2)[source]

Returns a function of one parameter u that interpolates linearly between the two rotations R1 and R2. After f(u) is constructed, calling f(u) is about 2x faster than calling interpolate(R1,R2,u).

Return type:

`Callable`

klampt.math.so3.det(R)[source]

Returns the determinant of the 3x3 matrix R

Return type:

`float`

klampt.math.so3.is_rotation(R, tol=1e-05)[source]

Returns true if R is a rotation matrix, i.e. is orthogonal to the given tolerance and has + determinant

Return type:

`bool`

klampt.math.so3.sample()[source]

Returns a uniformly distributed rotation matrix.

Return type:

`Sequence`[`float`]