nie S r SSKJr SSKrSSKrSSKrSrS rS rS r S r
S r S]S
jr S r
S^S jrS
r S_S jrS`S jrS`S jrS rS rS r SaS jrS rSbS jrScS jrScS jrScS jrScS jr S r S r S r S r S r!S! r"SdS" jr#S]S# jr$S]S$ jr% " S% S&\&5 r'S' r(S( r)S) r*\RV " \,5 RZ S*- r./ S+Qr/0 SS,_S-S._S/S0_S1S2_S3S4_S5S6_S7S8_S9S:_S;S<_S=S>_S?S@_SASB_SCSD_SESF_SGSH_SISJ_SKSL_SMSNSOSPSQSRSSST.Er0\1" SU \0Re 5 5 5 r3S^SV jr4S^SW jr5SX r6SY r7SZ r8S[ r9SeS\ jr:g)faZ Homogeneous Transformation Matrices and Quaternions.
A library for calculating 4x4 matrices for translating, rotating, reflecting,
scaling, shearing, projecting, orthogonalizing, and superimposing arrays of
3D homogeneous coordinates as well as for converting between rotation matrices,
Euler angles, and quaternions. Also includes an Arcball control object and
functions to decompose transformation matrices.
:Authors:
`Christoph Gohlke `__,
Laboratory for Fluorescence Dynamics, University of California, Irvine
:Version: 20090418
Requirements
------------
* `Python 2.6 `__
* `Numpy 1.3 `__
* `transformations.c 20090418 `__
(optional implementation of some functions in C)
Notes
-----
Matrices (M) can be inverted using numpy.linalg.inv(M), concatenated using
numpy.dot(M0, M1), or used to transform homogeneous coordinates (v) using
numpy.dot(M, v) for shape (4, \*) "point of arrays", respectively
numpy.dot(v, M.T) for shape (\*, 4) "array of points".
Calculations are carried out with numpy.float64 precision.
This Python implementation is not optimized for speed.
Vector, point, quaternion, and matrix function arguments are expected to be
"array like", i.e. tuple, list, or numpy arrays.
Return types are numpy arrays unless specified otherwise.
Angles are in radians unless specified otherwise.
Quaternions ix+jy+kz+w are represented as [x, y, z, w].
Use the transpose of transformation matrices for OpenGL glMultMatrixd().
A triple of Euler angles can be applied/interpreted in 24 ways, which can
be specified using a 4 character string or encoded 4-tuple:
*Axes 4-string*: e.g. 'sxyz' or 'ryxy'
- first character : rotations are applied to 's'tatic or 'r'otating frame
- remaining characters : successive rotation axis 'x', 'y', or 'z'
*Axes 4-tuple*: e.g. (0, 0, 0, 0) or (1, 1, 1, 1)
- inner axis: code of axis ('x':0, 'y':1, 'z':2) of rightmost matrix.
- parity : even (0) if inner axis 'x' is followed by 'y', 'y' is followed
by 'z', or 'z' is followed by 'x'. Otherwise odd (1).
- repetition : first and last axis are same (1) or different (0).
- frame : rotations are applied to static (0) or rotating (1) frame.
References
----------
(1) Matrices and transformations. Ronald Goldman.
In "Graphics Gems I", pp 472-475. Morgan Kaufmann, 1990.
(2) More matrices and transformations: shear and pseudo-perspective.
Ronald Goldman. In "Graphics Gems II", pp 320-323. Morgan Kaufmann, 1991.
(3) Decomposing a matrix into simple transformations. Spencer Thomas.
In "Graphics Gems II", pp 320-323. Morgan Kaufmann, 1991.
(4) Recovering the data from the transformation matrix. Ronald Goldman.
In "Graphics Gems II", pp 324-331. Morgan Kaufmann, 1991.
(5) Euler angle conversion. Ken Shoemake.
In "Graphics Gems IV", pp 222-229. Morgan Kaufmann, 1994.
(6) Arcball rotation control. Ken Shoemake.
In "Graphics Gems IV", pp 175-192. Morgan Kaufmann, 1994.
(7) Representing attitude: Euler angles, unit quaternions, and rotation
vectors. James Diebel. 2006.
(8) A discussion of the solution for the best rotation to relate two sets
of vectors. W Kabsch. Acta Cryst. 1978. A34, 827-828.
(9) Closed-form solution of absolute orientation using unit quaternions.
BKP Horn. J Opt Soc Am A. 1987. 4(4), 629-642.
(10) Quaternions. Ken Shoemake.
http://www.sfu.ca/~jwa3/cmpt461/files/quatut.pdf
(11) From quaternion to matrix and back. JMP van Waveren. 2005.
http://www.intel.com/cd/ids/developer/asmo-na/eng/293748.htm
(12) Uniform random rotations. Ken Shoemake.
In "Graphics Gems III", pp 124-132. Morgan Kaufmann, 1992.
Examples
--------
>>> alpha, beta, gamma = 0.123, -1.234, 2.345
>>> origin, xaxis, yaxis, zaxis = (0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1)
>>> I = identity_matrix()
>>> Rx = rotation_matrix(alpha, xaxis)
>>> Ry = rotation_matrix(beta, yaxis)
>>> Rz = rotation_matrix(gamma, zaxis)
>>> R = concatenate_matrices(Rx, Ry, Rz)
>>> euler = euler_from_matrix(R, 'rxyz')
>>> numpy.allclose([alpha, beta, gamma], euler)
True
>>> Re = euler_matrix(alpha, beta, gamma, 'rxyz')
>>> is_same_transform(R, Re)
True
>>> al, be, ga = euler_from_matrix(Re, 'rxyz')
>>> is_same_transform(Re, euler_matrix(al, be, ga, 'rxyz'))
True
>>> qx = quaternion_about_axis(alpha, xaxis)
>>> qy = quaternion_about_axis(beta, yaxis)
>>> qz = quaternion_about_axis(gamma, zaxis)
>>> q = quaternion_multiply(qx, qy)
>>> q = quaternion_multiply(q, qz)
>>> Rq = quaternion_matrix(q)
>>> is_same_transform(R, Rq)
True
>>> S = scale_matrix(1.23, origin)
>>> T = translation_matrix((1, 2, 3))
>>> Z = shear_matrix(beta, xaxis, origin, zaxis)
>>> R = random_rotation_matrix(numpy.random.rand(3))
>>> M = concatenate_matrices(T, R, Z, S)
>>> scale, shear, angles, trans, persp = decompose_matrix(M)
>>> numpy.allclose(scale, 1.23)
True
>>> numpy.allclose(trans, (1, 2, 3))
True
>>> numpy.allclose(shear, (0, math.tan(beta), 0))
True
>>> is_same_transform(R, euler_matrix(axes='sxyz', *angles))
True
>>> M1 = compose_matrix(scale, shear, angles, trans, persp)
>>> is_same_transform(M, M1)
True
)divisionNzrestructuredtext enc H [ R " S[ R S9$ )zReturn 4x4 identity/unit matrix.
>>> I = identity_matrix()
>>> numpy.allclose(I, numpy.dot(I, I))
True
>>> numpy.sum(I), numpy.trace(I)
(4.0, 4.0)
>>> numpy.allclose(I, numpy.identity(4, dtype=numpy.float64))
True
dtype)numpyidentityfloat64 X/home/james-whalen/.local/lib/python3.13/site-packages/pybullet_utils/transformations.pyidentity_matrixr s >>!5== 11r c J [ R " S5 nU SS USS2S4' U$ )zReturn matrix to translate by direction vector.
>>> v = numpy.random.random(3) - 0.5
>>> numpy.allclose(v, translation_matrix(v)[:3, 3])
True
r N )r r ) directionMs r
translation_matrixr s. qA!}Abqb!eH Hr c V [ R " U SS9SS2S4 R 5 $ )zReturn translation vector from translation matrix.
>>> v0 = numpy.random.random(3) - 0.5
>>> v1 = translation_from_matrix(translation_matrix(v0))
>>> numpy.allclose(v0, v1)
True
FcopyNr )r arrayr matrixs r
translation_from_matrixr s+ ;;vE *2A2q5 1 6 6 88r c [ USS 5 n[ R " S5 nUSS2SS24== S[ R " X5 - - ss' S[ R " U SS U5 - U- USS2S4' U$ )a Return matrix to mirror at plane defined by point and normal vector.
>>> v0 = numpy.random.random(4) - 0.5
>>> v0[3] = 1.0
>>> v1 = numpy.random.random(3) - 0.5
>>> R = reflection_matrix(v0, v1)
>>> numpy.allclose(2., numpy.trace(R))
True
>>> numpy.allclose(v0, numpy.dot(R, v0))
True
>>> v2 = v0.copy()
>>> v2[:3] += v1
>>> v3 = v0.copy()
>>> v2[:3] -= v1
>>> numpy.allclose(v2, numpy.dot(R, v3))
True
Nr r @) unit_vectorr r outerdot)pointnormalr s r
reflection_matrixr" s{ &
$F
qAbqb"1"fIu{{6222Ieiibq 622f>> v0 = numpy.random.random(3) - 0.5
>>> v1 = numpy.random.random(3) - 0.5
>>> M0 = reflection_matrix(v0, v1)
>>> point, normal = reflection_from_matrix(M0)
>>> M1 = reflection_matrix(point, normal)
>>> is_same_transform(M0, M1)
True
Fr r Nr ?:0yE>r z2no unit eigenvector corresponding to eigenvalue -11no unit eigenvector corresponding to eigenvalue 1) r r r
linalgeigwhereabsreallen
ValueErrorsqueeze)r r lVir! r s r
reflection_from_matrixr4 s. F%--e>> angle = (random.random() - 0.5) * (2*math.pi)
>>> direc = numpy.random.random(3) - 0.5
>>> point = numpy.random.random(3) - 0.5
>>> R0 = rotation_matrix(angle, direc, point)
>>> R1 = rotation_matrix(angle-2*math.pi, direc, point)
>>> is_same_transform(R0, R1)
True
>>> R0 = rotation_matrix(angle, direc, point)
>>> R1 = rotation_matrix(-angle, -direc, point)
>>> is_same_transform(R0, R1)
True
>>> I = numpy.identity(4, numpy.float64)
>>> numpy.allclose(I, rotation_matrix(math.pi*2, direc))
True
>>> numpy.allclose(2., numpy.trace(rotation_matrix(math.pi/2,
... direc, point)))
True
Nr r r% r r Fr$ )
mathsincosr r r r
r r r )angler r sinacosaRr s r
rotation_matrixr@ sR , 88E?D 88E?DIbqM*I
dC#&D#&C$')05
?A Y *cDj 99A
Iil]Yq\B!! cYq\MB!! }ilS9; !==
* *A qAbqb"1"fI E"1IU]]G599Q.."1"a% Hr c [ R " U [ R SS9nUSS2SS24 n[ R R UR
5 u p4[ R " [ [ R " U5 S-
5 S: 5 S n[ U5 ( d [ S5 e[ R " USS2US 4 5 R 5 n[ R R U5 u p7[ R " [ [ R " U5 S-
5 S: 5 S n[ U5 ( d [ S5 e[ R " USS2US 4 5 R 5 nXS - n[ R " U5 S-
S
- n [ US 5 S: a US U S-
US - US
- - US - n
OM[ US
5 S: a US U S-
US - US - - US
- n
O US U S-
US
- US - - US - n
[ R " X5 n XU4$ )am Return rotation angle and axis from rotation matrix.
>>> angle = (random.random() - 0.5) * (2*math.pi)
>>> direc = numpy.random.random(3) - 0.5
>>> point = numpy.random.random(3) - 0.5
>>> R0 = rotation_matrix(angle, direc, point)
>>> angle, direc, point = rotation_from_matrix(R0)
>>> R1 = rotation_matrix(angle, direc, point)
>>> is_same_transform(R0, R1)
True
Fr$ Nr r% r& r r' r( r r7 r8 r r8 r r7 r7 r8 )r r r
r) r* Tr+ r, r- r. r/ r0 tracer9 atan2) r r? R33r1 Wr3 r Qr r> r= r< s r
rotation_from_matrixrK ? s F%--e>)A,N Yq\ T !$48Yq\1)A,>>)A,N$48Yq\1)A,>>)A,N JJt "E U ""r c UcX [ R " U SSS4SU SS4SSU S4S4[ R S9nUb USS USS2S4' USS2S4== SU -
- ss' U$ [ USS 5 nSU -
n [ R " S5 nUSS2SS24== U [ R
" X"5 - - ss' Ub' U [ R " USS U5 - U- USS2S4' U$ )a Return matrix to scale by factor around origin in direction.
Use factor -1 for point symmetry.
>>> v = (numpy.random.rand(4, 5) - 0.5) * 20.0
>>> v[3] = 1.0
>>> S = scale_matrix(-1.234)
>>> numpy.allclose(numpy.dot(S, v)[:3], -1.234*v[:3])
True
>>> factor = random.random() * 10 - 5
>>> origin = numpy.random.random(3) - 0.5
>>> direct = numpy.random.random(3) - 0.5
>>> S = scale_matrix(factor, origin)
>>> S = scale_matrix(factor, origin, direct)
Nr6 r6 r6 r6 r% r r r% r )r r r
r r r r )factororiginr r s r
scale_matrixrP g s " KK&###6 &##6 #ʜ @E}}
N bqzAbqb!eH
bqb!eHf $H
H
"1
. v NN1 "1"bqb& Vekk) ??? 6"1:y!AAYNAbqb!eH Hr c \ [ R " U [ R SS9nUSS2SS24 n[ R " U5 S-
n [ R R U5 u pE[ R " [ [ R " U5 U-
5 S: 5 S S n[ R " USS2U4 5 R 5 nU[ U5 - n[ R R U5 u pE[ R " [ [ R " U5 S -
5 S: 5 S n[ U5 ( d [ S
5 e[ R " USS2US 4 5 R 5 nXS - nX8U4$ ! [ a
US- S- nSn Nf = f) a% Return scaling factor, origin and direction from scaling matrix.
>>> factor = random.random() * 10 - 5
>>> origin = numpy.random.random(3) - 0.5
>>> direct = numpy.random.random(3) - 0.5
>>> S0 = scale_matrix(factor, origin)
>>> factor, origin, direction = scale_from_matrix(S0)
>>> S1 = scale_matrix(factor, origin, direction)
>>> is_same_transform(S0, S1)
True
>>> S0 = scale_matrix(factor, origin, direct)
>>> factor, origin, direction = scale_from_matrix(S0)
>>> S1 = scale_matrix(factor, origin, direction)
>>> is_same_transform(S0, S1)
True
Fr$ Nr r r& r g @r% ,no eigenvector corresponding to eigenvalue 1r( )r r r
rF r) r* r+ r, r- r0 vector_norm
IndexErrorr. r/ ) r r M33rN r1 r2 r3 r rO s r
scale_from_matrixrV so $ F%--eq AJJqAw'//1 [++ << A DA
C
1
+,t34Q7A q66GHH
ZZ!QrU(
$
,
,
.F
QiF 9 $$ 3,#% s
BF F+*F+c d [ R " S5 n[ R " U SS [ R SS9n [ USS 5 nUGb
[ R " USS [ R SS9n[ R
" X0-
U5 =US' =US' US' USS2SS24== [ R " X15 - ss' U( aJ USS2SS24== [ R " X5 - ss' [ R
" X5 X1- - USS2S4' O [ R
" X5 U- USS2S4' U* USSS24' [ R
" X15 US ' U$ Ub [ R " USS [ R SS9n[ R
" X!5 nUSS2SS24== [ R " X!5 U- - ss' U[ R
" X5 U- - USS2S4' U$ USS2SS24== [ R " X5 - ss' [ R
" X5 U- USS2S4' U$ )
a( Return matrix to project onto plane defined by point and normal.
Using either perspective point, projection direction, or none of both.
If pseudo is True, perspective projections will preserve relative depth
such that Perspective = dot(Orthogonal, PseudoPerspective).
>>> P = projection_matrix((0, 0, 0), (1, 0, 0))
>>> numpy.allclose(P[1:, 1:], numpy.identity(4)[1:, 1:])
True
>>> point = numpy.random.random(3) - 0.5
>>> normal = numpy.random.random(3) - 0.5
>>> direct = numpy.random.random(3) - 0.5
>>> persp = numpy.random.random(3) - 0.5
>>> P0 = projection_matrix(point, normal)
>>> P1 = projection_matrix(point, normal, direction=direct)
>>> P2 = projection_matrix(point, normal, perspective=persp)
>>> P3 = projection_matrix(point, normal, perspective=persp, pseudo=True)
>>> is_same_transform(P2, numpy.dot(P0, P3))
True
>>> P = projection_matrix((3, 0, 0), (1, 1, 0), (1, 0, 0))
>>> v0 = (numpy.random.rand(4, 5) - 0.5) * 20.0
>>> v0[3] = 1.0
>>> v1 = numpy.dot(P, v0)
>>> numpy.allclose(v1[1], v0[1])
True
>>> numpy.allclose(v1[0], 3.0-v1[1])
True
r Nr Fr$ r r r8 r8 r7 r7 r r )r r r r
r r r )r r! r perspectivepseudor scales r
projection_matrixr_ s @ qA KKbq U CE
$F kk+bq/ ',. &+ii 0A6&JJ$J!D'AdG "1"bqb& U[[55
bqb"1"fIV4 4I yy/;3EFAbqb!eH yy/+=Abqb!eH7!RaR%))K0$
H
KK "1
U]]O ), "1"bqb& U[[3e;; % 85 @A"1"a%
H
"1"bqb& U[[00 99U+f4"1"a% Hr c [ R " U [ R SS9nUSS2SS24 n[ R R U5 u pE[ R
" [
[ R " U5 S-
5 S: 5 S nU( Gd [ U5 ( Ga [ R " USS2US 4 5 R 5 nXwS - n[ R R U5 u pE[ R
" [
[ R " U5 5 S: 5 S n[ U5 ( d [ S 5 e[ R " USS2US 4 5 R 5 nU[ U5 - n[ R R UR 5 u pE[ R
" [
[ R " U5 5 S: 5 S n[ U5 ( aB [ R " USS2US 4 5 R 5 n U [ U 5 - n XyUSS4$ XxSSS4$ [ R
" [
[ R " U5 5 S: 5 S n[ U5 ( d [ S
5 e[ R " USS2US 4 5 R 5 nXwS - nUSSS24 * n USS2S4 [ R " USS U 5 - n
U( a X- n
XySX4$ ) a. Return projection plane and perspective point from projection matrix.
Return values are same as arguments for projection_matrix function:
point, normal, direction, perspective, and pseudo.
>>> point = numpy.random.random(3) - 0.5
>>> normal = numpy.random.random(3) - 0.5
>>> direct = numpy.random.random(3) - 0.5
>>> persp = numpy.random.random(3) - 0.5
>>> P0 = projection_matrix(point, normal)
>>> result = projection_from_matrix(P0)
>>> P1 = projection_matrix(*result)
>>> is_same_transform(P0, P1)
True
>>> P0 = projection_matrix(point, normal, direct)
>>> result = projection_from_matrix(P0)
>>> P1 = projection_matrix(*result)
>>> is_same_transform(P0, P1)
True
>>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=False)
>>> result = projection_from_matrix(P0, pseudo=False)
>>> P1 = projection_matrix(*result)
>>> is_same_transform(P0, P1)
True
>>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=True)
>>> result = projection_from_matrix(P0, pseudo=True)
>>> P1 = projection_matrix(*result)
>>> is_same_transform(P0, P1)
True
Fr$ Nr r% r& r r( z,no eigenvector corresponding to eigenvalue 0z0no eigenvector not corresponding to eigenvalue 0)r r r
r) r* r+ r, r- r. r0 r/ rS rE r ) r r] r rU r1 r2 r3 r r r! r\ s r
projection_from_matrixra s @ F%--e>> frustrum = numpy.random.rand(6)
>>> frustrum[1] += frustrum[0]
>>> frustrum[3] += frustrum[2]
>>> frustrum[5] += frustrum[4]
>>> M = clip_matrix(*frustrum, perspective=False)
>>> numpy.dot(M, [frustrum[0], frustrum[2], frustrum[4], 1.0])
array([-1., -1., -1., 1.])
>>> numpy.dot(M, [frustrum[1], frustrum[3], frustrum[5], 1.0])
array([ 1., 1., 1., 1.])
>>> M = clip_matrix(*frustrum, perspective=True)
>>> v = numpy.dot(M, [frustrum[0], frustrum[2], frustrum[4], 1.0])
>>> v / v[3]
array([-1., -1., -1., 1.])
>>> v = numpy.dot(M, [frustrum[1], frustrum[3], frustrum[4], 1.0])
>>> v / v[3]
array([ 1., 1., -1., 1.])
zinvalid frustrumzinvalid frustrum: near <= 0r r6 )r6 r6 r6 rM r )r/ _EPSr r r
) leftrightbottomtopnearfarr\ tr s r
clip_matrixrl < s D }
+,, 4< :; ; $Jb%*osUZ%*$=s
CA2sz?SZ#*$=s
C3#( SX.sx0@
A
"
$
5: S5:
*C
D3
#S3:
*C
D3SXDH(=
>
!
# ;;q
..r c [ USS 5 n[ USS 5 n[ [ R " X15 5 S: a [ S5 e[
R " U 5 n [ R " S5 nUSS2SS24== U [ R " X5 - -
ss' U * [ R " USS U5 - U- USS2S4' U$ )a Return matrix to shear by angle along direction vector on shear plane.
The shear plane is defined by a point and normal vector. The direction
vector must be orthogonal to the plane's normal vector.
A point P is transformed by the shear matrix into P" such that
the vector P-P" is parallel to the direction vector and its extent is
given by the angle of P-P'-P", where P' is the orthogonal projection
of P onto the shear plane.
>>> angle = (random.random() - 0.5) * 4*math.pi
>>> direct = numpy.random.random(3) - 0.5
>>> point = numpy.random.random(3) - 0.5
>>> normal = numpy.cross(direct, numpy.random.random(3))
>>> S = shear_matrix(angle, direct, point, normal)
>>> numpy.allclose(1.0, numpy.linalg.det(S))
True
Nr gư>z/direction and normal vectors are not orthogonalr ) r r, r r r/ r9 tanr r )r< r r r! r s r
shear_matrixro p s (
$FIbqM*I
599V '(4/JKK HHUOE
qAbqb"1"fIY777Iv %)V44y@Abqb!eH Hr c d [ R " U [ R SS9nUSS2SS24 n[ R R U5 u p4[ R
" [
[ R " U5 S-
5 S: 5 S n[ U5 S: a [ S R U5 5 e[ R " USS2U4 5 R 5 R nS
nS H6 u px[ R " XG XH 5 n [ U 5 nX6: d M2 UnU n
M8 W
U- n
[ R " U[ R " S5 -
U
5 n [ U 5 n X- n [" R$ " U 5 n [ R R U5 u p4[ R
" [
[ R " U5 S-
5 S : 5 S n[ U5 ( d [ S
5 e[ R " USS2US 4 5 R 5 n
XS - n
XX4$ )a Return shear angle, direction and plane from shear matrix.
>>> angle = (random.random() - 0.5) * 4*math.pi
>>> direct = numpy.random.random(3) - 0.5
>>> point = numpy.random.random(3) - 0.5
>>> normal = numpy.cross(direct, numpy.random.random(3))
>>> S0 = shear_matrix(angle, direct, point, normal)
>>> angle, direct, point, normal = shear_from_matrix(S0)
>>> S1 = shear_matrix(angle, direct, point, normal)
>>> is_same_transform(S0, S1)
True
Fr$ Nr r% g-C 6?r r7 z/No two linear independent eigenvectors found {}rc )r r8 rC r8 r7 r& rR r( )r r r
r) r* r+ r, r- r. r/ formatr0 rE crossrS r r r9 atan)r r rU r1 r2 r3 lenormi0i1nr! r r< r s r
shear_from_matrixrz s F%--e>> T0 = translation_matrix((1, 2, 3))
>>> scale, shear, angles, trans, persp = decompose_matrix(T0)
>>> T1 = translation_matrix(trans)
>>> numpy.allclose(T0, T1)
True
>>> S = scale_matrix(0.123)
>>> scale, shear, angles, trans, persp = decompose_matrix(S)
>>> scale[0]
0.123
>>> R0 = euler_matrix(1, 2, 3)
>>> scale, shear, angles, trans, persp = decompose_matrix(R0)
>>> R1 = euler_matrix(*angles)
>>> numpy.allclose(R0, R1)
True
Tr$ r[ zM[3, 3] is zeror r r r8 Nr zMatrix is singular)r r )r r r r r8 r7 r( rC rr rZ rq rX rD rY r6 )r r r
rE r, rd r/ r r) detzerosanyr invrS rt r9 asinr; rG ) r r Pr^ shearanglesr\ translaterows r
decompose_matrixr sZ > F%--d;==A
1T7|d*++4LA AAadG << A -.. KKU]] 3E E
F
3q!Qx=4 ii!Q$ )9)9!##)>? !Q$kk,emmD !RaR%
IAa!eH
BQBF)..
C3q6"E!HFeAhFyyQQ(E!HFc!fuQx F3q6"E!HFeAhF !HaHyyQQ(E!HFc!fuQx FyyQQ(E!HFc!fuQx F3q6"E!HFeAhF !"IqI yyQSVSV459
r 3t9*%F1I xxq JJs4y#d)4q JJs4y#d)4q JJD z3t95q q K 77r c [ R " S5 nUb8 [ R " S5 nUSS USSS24' [ R " XV5 nUb8 [ R " S5 nUSS USS2S4' [ R " XW5 nUb- [ US US US S5 n[ R " XX5 nUbD [ R " S5 n US U S' US U S ' US U S
' [ R " XY5 nU bD [ R " S5 n
U S U
S ' U S U
S ' U S U
S
' [ R " XZ5 nXUS - nU$ )a Return transformation matrix from sequence of transformations.
This is the inverse of the decompose_matrix function.
Sequence of transformations:
scale : vector of 3 scaling factors
shear : list of shear factors for x-y, x-z, y-z axes
angles : list of Euler angles about static x, y, z axes
translate : translation vector along x, y, z axes
perspective : perspective partition of matrix
>>> scale = numpy.random.random(3) - 0.5
>>> shear = numpy.random.random(3) - 0.5
>>> angles = (numpy.random.random(3) - 0.5) * (2*math.pi)
>>> trans = numpy.random.random(3) - 0.5
>>> persp = numpy.random.random(4) - 0.5
>>> M0 = compose_matrix(scale, shear, angles, trans, persp)
>>> result = decompose_matrix(M0)
>>> M1 = compose_matrix(*result)
>>> is_same_transform(M0, M1)
True
r Nr r r8 r7 sxyzrr rC rq rX rY rZ r[ )r r r euler_matrix) r^ r r r r\ r r rE r? ZSs r
compose_matrixr sM 2 qA NN1 bq/!Q$ IIaO NN1 Ra="1"a% IIaO
F1Ivay& A IIaO NN1 ($($($ IIaO NN1 ($($($ IIaO4LA Hr c p U u p#n[ R " U5 n[ R " U5 u pVn[ R " U5 u pn
X- U
-
XV- - n [ R " X&- [
R " SX- -
5 - SSS4U* U- U - X5- SS4X)- X8- US4S4[ R S9$ )a Return orthogonalization matrix for crystallographic cell coordinates.
Angles are expected in degrees.
The de-orthogonalization matrix is the inverse.
>>> O = orthogonalization_matrix((10., 10., 10.), (90., 90., 90.))
>>> numpy.allclose(O[:3, :3], numpy.identity(3, float) * 10)
True
>>> O = orthogonalization_matrix([9.8, 12.0, 15.5], [87.2, 80.7, 69.7])
>>> numpy.allclose(numpy.sum(O), 43.063229)
True
r% r6 rM r )r radiansr: r; r r9 sqrtr
) lengthsr abcr= sinb_r> cosbcosgcos r
orthogonalization_matrixr F s GA!
]]6
"FIIf%MD yy(D
+
-B ;;
&3ru9%
%S9
DS9
&S99 ;
mm r c [ R " U [ R SS9SS n [ R " U[ R SS9SS nU R UR :w d U R S S: a [ S5 e[ R
" U SS9n[ R
" USS9nXR
SS5 -
n XR
SS5 -
nU( a [ R R [ R " XR 5 5 u pgn[ R " Xh5 n [ R R U 5 S: a8 U [ R " USS2S 4 US SS24 S
- 5 - n US == S - ss' [ R " S
5 n
XSS2SS24' GO:[ R " X- SS9u pn
[ R " U [ R " US SS9- SS9u pn[ R " U [ R " USSS9- SS9u nnnX- U
- UU-
UU-
UU-
4UU-
X-
U
-
UU- UU- 4UU-
UU- U * U - U
-
UU- 4UU-
UU- UU- U * U -
U
- 44n[ R R! U5 u nnUSS2[ R" " U5 4 nU[% U5 - n[ R " US 5 n[' U5 n
U( aZ X - n X- nU
SS2SS24== [( R* " [ R " U5 [ R " U 5 - 5 - ss' XZSS2S4' [ R " S
5 nU* USS2S4' [ R " U
U5 n
U
$ )aA Return matrix to transform given vector set into second vector set.
v0 and v1 are shape (3, \*) or (4, \*) arrays of at least 3 vectors.
If usesvd is True, the weighted sum of squared deviations (RMSD) is
minimized according to the algorithm by W. Kabsch [8]. Otherwise the
quaternion based algorithm by B. Horn [9] is used (slower when using
this Python implementation).
The returned matrix performs rotation, translation and uniform scaling
(if specified).
>>> v0 = numpy.random.rand(3, 10)
>>> M = superimposition_matrix(v0, v0)
>>> numpy.allclose(M, numpy.identity(4))
True
>>> R = random_rotation_matrix(numpy.random.random(3))
>>> v0 = ((1,0,0), (0,1,0), (0,0,1), (1,1,1))
>>> v1 = numpy.dot(R, v0)
>>> M = superimposition_matrix(v0, v1)
>>> numpy.allclose(v1, numpy.dot(M, v0))
True
>>> v0 = (numpy.random.rand(4, 100) - 0.5) * 20.0
>>> v0[3] = 1.0
>>> v1 = numpy.dot(R, v0)
>>> M = superimposition_matrix(v0, v1)
>>> numpy.allclose(v1, numpy.dot(M, v0))
True
>>> S = scale_matrix(random.random())
>>> T = translation_matrix(numpy.random.random(3)-0.5)
>>> M = concatenate_matrices(T, R, S)
>>> v1 = numpy.dot(M, v0)
>>> v0[:3] += numpy.random.normal(0.0, 1e-9, 300).reshape(3, -1)
>>> M = superimposition_matrix(v0, v1, scaling=True)
>>> numpy.allclose(v1, numpy.dot(M, v0))
True
>>> M = superimposition_matrix(v0, v1, scaling=True, usesvd=False)
>>> numpy.allclose(v1, numpy.dot(M, v0))
True
>>> v = numpy.empty((4, 100, 3), dtype=numpy.float64)
>>> v[:, :, 0] = v0
>>> M = superimposition_matrix(v0, v1, scaling=True, usesvd=False)
>>> numpy.allclose(v1, numpy.dot(M, v[:, :, 0]))
True
Fr$ Nr r8 z'Vector sets are of wrong shape or type.axisr6 r7 r r( rc r r )r r r
shaper/ meanreshaper) svdr rE r} r r sumrollr* argmaxrS quaternion_matrixr9 r )v0v1scalingusesvdt0t1usvhr? r xxyyzzxyyzzxxzyxzyNr1 r2 qrE s r
superimposition_matrixr b s, ^
Ru}}5 9"1 =B Ru}}5 9"1 =B xx288rxx{QBCC
BQ B BQ B jjA B jjA B
<<##EIIb$$$78b IIa << A $
Qq!tWbAhsl3 3A
bETME NN1 "1"bqb& YYrwQ/
YYrEJJr2A$> >QG
YYrEJJr2A$> >QG
BeBh2"R%BrE
2eb"R%BrE
2e2"RBrE
2e2"R%B3r6"9
5
7
|| "1
a a ! [^ JJq" a
"1"bqb& TYYuyy}uyy} <== bqb!eH
qAsAbqb!eH
!QA Hr r c [ U u pEpgUn [ X- n
[ X-
S- n U( a X p U( a U * U* U* p!n [
R " U 5 [
R " U5 [
R " U5 pn [
R " U 5 [
R " U5 [
R " U5 nnnUU- X- nnU U- X- nn[ R " S5 nU( a\ UUX4' X- UX4' X- UX4' X- UX4' U* U- U- UX4' U* U- U-
UX4' U
* U- UX4' UU- U- UX4' UU- U-
UX4' U$ UU- UX4' U
U- U-
UX4' U
U- U- UX4' UU- UX4' U
U- U- UX4' U
U- U-
UX4' U
* UX4' UU - UX4' UU- UX4' U$ ! [ [ 4 a [ U nUu pEpg GNf = f)aQ Return homogeneous rotation matrix from Euler angles and axis sequence.
ai, aj, ak : Euler's roll, pitch and yaw angles
axes : One of 24 axis sequences as string or encoded tuple
>>> R = euler_matrix(1, 2, 3, 'syxz')
>>> numpy.allclose(numpy.sum(R[0]), -1.34786452)
True
>>> R = euler_matrix(1, 2, 3, (0, 1, 0, 1))
>>> numpy.allclose(numpy.sum(R[0]), -0.383436184)
True
>>> ai, aj, ak = (4.0*math.pi) * (numpy.random.random(3) - 0.5)
>>> for axes in _AXES2TUPLE.keys():
... R = euler_matrix(ai, aj, ak, axes)
>>> for axes in _TUPLE2AXES.keys():
... R = euler_matrix(ai, aj, ak, axes)
r8 r )
_AXES2TUPLEAttributeErrorKeyError _TUPLE2AXES
_NEXT_AXISr9 r: r; r r )aiajakaxes firstaxisparity
repetitionframer r3 jksisjskcicjckcccsscssr s r
r r s/ &4/:4/@, :
A18 A18A: A B
S2#s" txx|TXXb\BB" txx|TXXb\BB
UBEB
UBEB
qA!$%!$%!$%!$#b&)!$#b&)!$#b&!$R%(!$R%(!$
H R%!$R%(!$R%(!$R%!$R%(!$R%(!$#!$R%!$R%!$ HO
H % 4 /3, :u4s F, , G
Gc [ UR 5 u p#pEUn[
Xs- n[
Xs-
S- n [ R " U [ R SS9SS2SS24 n
U( a [ R " XU4 XU4 - XU 4 XU 4 - - 5 n U [ : a[ [ R " XU4 XU 4 5 n [ R " XXw4 5 n
[ R " XU4 XU4 * 5 nGO[ R " XU 4 * XU4 5 n [ R " XXw4 5 n
SnO[ R " XU4 XU4 - XU4 XU4 - - 5 nU[ : a[ [ R " XU4 XU 4 5 n [ R " XU4 * U5 n
[ R " XU4 XU4 5 nO>[ R " XU 4 * XU4 5 n [ R " XU4 * U5 n
SnU( a U * U
* U* pn U( a XpXU4$ ! [ [ 4 a [ U nUu p#pE GN/f = f)al Return Euler angles from rotation matrix for specified axis sequence.
axes : One of 24 axis sequences as string or encoded tuple
Note that many Euler angle triplets can describe one matrix.
>>> R0 = euler_matrix(1, 2, 3, 'syxz')
>>> al, be, ga = euler_from_matrix(R0, 'syxz')
>>> R1 = euler_matrix(al, be, ga, 'syxz')
>>> numpy.allclose(R0, R1)
True
>>> angles = (4.0*math.pi) * (numpy.random.random(3) - 0.5)
>>> for axes in _AXES2TUPLE.keys():
... R0 = euler_matrix(axes=axes, *angles)
... R1 = euler_matrix(axes=axes, *euler_from_matrix(R0, axes))
... if not numpy.allclose(R0, R1): print axes, "failed"
r8 Fr$ Nr r6 )
r lowerr r r r r r r
r9 r rd rG )r r r r r r r r3 r r r syaxayazcys r
euler_from_matrixr s@ &4/:4::>> angles = euler_from_quaternion([0.06146124, 0, 0, 0.99810947])
>>> numpy.allclose(angles, [0.123, 0, 0])
True
)r r )
quaternionr s r
euler_from_quaternionr A s .z :D AAr c v [ UR 5 u pEpgUn [
X- n
[
X-
S- n U( a X p U( a U* nU S- n US- nUS- n[ R " U 5 n [ R " U 5 n
[ R " U5 n[ R " U5 n[ R " U5 n[ R " U5 nU U- nU U- nU
U- nU
U- n[ R " S[ R S9nU( a- UUU- - UU ' UUU- - UU
' UUU-
- UU ' UUU-
- US' O8UU- UU- -
UU ' UU- UU- - UU
' UU- UU- -
UU ' UU- UU- - US' U( a
UU
== S- ss' U$ ! [ [ 4 a [ U nUu pEpg GNf = f)a Return quaternion from Euler angles and axis sequence.
ai, aj, ak : Euler's roll, pitch and yaw angles
axes : One of 24 axis sequences as string or encoded tuple
>>> q = quaternion_from_euler(1, 2, 3, 'ryxz')
>>> numpy.allclose(q, [0.310622, -0.718287, 0.444435, 0.435953])
True
r8 r r r r r( ) r r r r r r r9 r; r: r emptyr
)r r r r r r r r r r3 r r r r r r r r r r r r r s r
quaternion_from_eulerr L s 4/:4::>> q = quaternion_about_axis(0.123, (1, 0, 0))
>>> numpy.allclose(q, [0.06146124, 0, 0, 0.99810947])
True
r r Nr r )r r~ r
rS rd r9 r: r; )r< r r qlens r
quaternion_about_axisr sr U%--8J"1XJrN z "D d{dhhuSy)D00
HHU3Y'JqM r c : [ R " U SS [ R SS9n[ R " X5 nU[ : a [ R
" S5 $ U[ R " SU- 5 - n[ R " X5 n[ R " SUS -
US -
US US
-
US US - S
4US US
- SUS -
US -
US US -
S
4US US -
US US - SUS -
US -
S
4S4[ R S9$ )zReturn homogeneous rotation matrix from quaternion.
>>> R = quaternion_matrix([0.06146124, 0, 0, 0.99810947])
>>> numpy.allclose(R, rotation_matrix(0.123, (1, 0, 0)))
True
Nr Tr$ r r% rY rZ rq )r7 r rC )r8 r r6 rX rr )r r rM r ) r r r
r rd r r9 r r )r r nqs r
r r s) JrN%--dCA 1 B Dy~~a 38 A
AA ;; QtWQtW !D'!D'/qwqwL
tWQtW_c!D'k!D' 1qwqwL
tWQtW_!D'!D'/3qw;qw3FLL
r c j [ R " S[ R S9n[ R " U [ R SS9SS2SS24 n[ R " U5 nX2S : a/ X1S' US US
-
US ' US US
-
US' US US -
US' OtSu pEnUS US : a Su pEnUS X$U4 : a Su pEnX$U4 X%U4 X&U4 - -
US - nX1U' X$U4 X%U4 - X' X&U4 X$U4 - X' X&U4 X%U4 -
US' US[
R " X2S - 5 - - nU$ )zReturn quaternion from rotation matrix.
>>> R = rotation_matrix(0.123, (1, 2, 3))
>>> q = quaternion_from_matrix(R)
>>> numpy.allclose(q, [0.0164262, 0.0328524, 0.0492786, 0.9981095])
True
r r Fr$ Nr r[ r rB rq r7 rC )r7 r r8 rD rr r )r r8 r7 rY rX )r8 r7 r rZ )r7 r r8 g ?)r r r
r rF r9 r )r r r rk r3 r r s r
quaternion_from_matrixr sy E /A
F%--e>> q = quaternion_multiply([1, -2, 3, 4], [-5, 6, 7, 8])
>>> numpy.allclose(q, [-44, -14, 48, 28])
True
r r r r
)
quaternion1 quaternion0x0y0z0w0x1y1z1w1s
r
quaternion_multiplyr s !NBB NBB ;; & B & & B & ( 05}} > >r c n [ R " U S * U S * U S * U S 4[ R S9$ )zReturn conjugate of quaternion.
>>> q0 = random_quaternion()
>>> q1 = quaternion_conjugate(q0)
>>> q1[3] == q0[3] and all(q1[:3] == -q0[:3])
True
r r8 r7 r r r r s r
quaternion_conjugater sB ;;A A #A
1
7>Cmm M Mr c F [ U 5 [ R " X 5 - $ )zReturn inverse of quaternion.
>>> q0 = random_quaternion()
>>> q1 = quaternion_inverse(q0)
>>> numpy.allclose(quaternion_multiply(q0, q1), [0, 0, 0, 1])
True
)r r r r s r
quaternion_inverser s
+eii
.O OOr c . [ U SS 5 n[ USS 5 nUS:X a U$ US:X a U$ [ R " XV5 n[ [ U5 S-
5 [ : a U$ U( a US: a U* nUS- n[
R " U5 U[
R - - n[ U5 [ : a U$ S[
R " U5 - n U[
R " SU-
U- 5 U - - nU[
R " X(- 5 U - - nXV-
nU$ )a Return spherical linear interpolation between two quaternions.
>>> q0 = random_quaternion()
>>> q1 = random_quaternion()
>>> q = quaternion_slerp(q0, q1, 0.0)
>>> numpy.allclose(q, q0)
True
>>> q = quaternion_slerp(q0, q1, 1.0, 1)
>>> numpy.allclose(q, q1)
True
>>> q = quaternion_slerp(q0, q1, 0.5)
>>> angle = math.acos(numpy.dot(q0, q))
>>> numpy.allclose(2.0, math.acos(numpy.dot(q0, q1)) / angle) or numpy.allclose(2.0, math.acos(-numpy.dot(q0, q1)) / angle)
True
Nr r6 r% rc ) r r r r, rd r9 acospir: )
quat0quat1fractionspin shortestpathq0q1dr< isins
r
quaternion_slerpr
s $
U2AY B U2AY B3 S
"A
3q6C<4 C
B
d
IIaL4$''> )E
5zD % D$((C(Ne+
,t
33B$((8#
$t
++BHB
Ir c U c [ R R S5 n O[ U 5 S:X d e[ R " SU S -
5 n[ R " U S 5 n[
R S- nX0S - nX0S - n[ R " [ R " U5 U- [ R " U5 U- [ R " U5 U- [ R " U5 U- 4[ R S9$ )a* Return uniform random unit quaternion.
rand: array like or None
Three independent random variables that are uniformly distributed
between 0 and 1.
>>> q = random_quaternion()
>>> numpy.allclose(1.0, vector_norm(q))
True
>>> q = random_quaternion(numpy.random.random(3))
>>> q.shape
(4,)
r r% r r r8 r7 r ) r randomrandr. r r9 r r r: r; r
)r
r1r2pi2r t2s r
random_quaternionr s ||| #4yA~ ~ C$q'M "B DG B
''C-C Aw B Aw B ;; "
b( "
b( "
b( "
b(* 27 @ @r c * [ [ U 5 5 $ )a Return uniform random rotation matrix.
rnd: array like
Three independent random variables that are uniformly distributed
between 0 and 1 for each returned quaternion.
>>> R = random_rotation_matrix()
>>> numpy.allclose(numpy.dot(R.T, R), numpy.identity(4))
True
)r r )r
s r
random_rotation_matrixr = s .t 4 55r c V \ rS rSrSrSS jrS rS rS rS r S r
S
r SS jr S r
S
rg)ArcballiL a Virtual Trackball Control.
>>> ball = Arcball()
>>> ball = Arcball(initial=numpy.identity(4))
>>> ball.place([320, 320], 320)
>>> ball.down([500, 250])
>>> ball.drag([475, 275])
>>> R = ball.matrix()
>>> numpy.allclose(numpy.sum(R), 3.90583455)
True
>>> ball = Arcball(initial=[0, 0, 0, 1])
>>> ball.place([320, 320], 320)
>>> ball.setaxes([1,1,0], [-1, 1, 0])
>>> ball.setconstrain(True)
>>> ball.down([400, 200])
>>> ball.drag([200, 400])
>>> R = ball.matrix()
>>> numpy.allclose(numpy.sum(R), 0.2055924)
True
>>> ball.next()
Nc SU l SU l SU l SS/U l [ R
" / SQ[ R S9U l SU l Uc+ [ R
" / SQ[ R S9U l Ot[ R
" U[ R S9nUR S:X a [ U5 U l O0UR S :X a U[ U5 - nXl O [ S
5 eU R =U l U l g) zPInitialize virtual trackball control.
initial : quaternion or rotation matrix
Nr% r6 )r r r8 r Fr| )r r r z#initial not a quaternion or matrix.)_axis_axes_radius_centerr r r
_vdown
_constrain_qdownr r rS r/ _qnow_qpre)selfinitials r
__init__Arcball.__init__d s
Sz kk)5==A ? ++l%--HDKkk' ?G}}& 4W = %';w// % !FGG"&++-
TZr c l [ U5 U l US U R S' US U R S' g)zPlace Arcball, e.g. when window size changes.
center : sequence[2]
Window coordinates of trackball center.
radius : float
Radius of trackball in window coordinates.
r r8 N)floatr r )r! centerradiuss r
place
Arcball.place s1 V} ) Q ) Qr c f Uc SU l gU Vs/ s H n[ U5 PM snU l gs snf )z Set axes to constrain rotations.N)r r )r! r r s r
setaxesArcball.setaxes s, < DJ8<=+d+=DJ=s .c US:H U l g)z$Set state of constrain to axis mode.TNr )r! constrains r
setconstrainArcball.setconstrain s #t+r c U R $ )z'Return state of constrain to axis mode.r/ r! s r
getconstrainArcball.getconstrain s r c ^ [ XR U R 5 U l U R =U l U l U R ( aX U R bK [ U R U R 5 U l
[ U R U R 5 U l gSU l
g)z>Set initial cursor window coordinates and pick constrain-axis.N) arcball_map_to_spherer r r r r r r r arcball_nearest_axisr arcball_constrain_to_axis)r! r s r
down Arcball.down sm +E<< N #'::- dj ??tzz 5-dkk4::FDJ3DKKLDK DJr c [ XR U R 5 nU R b [ X R 5 nU R
U l [ R " U R U5 n[ R " X35 [ : a U R U l gUS US US [ R " U R U5 /n[ X@R 5 U l g)z)Update current cursor window coordinates.Nr r8 r7 )r8 r r r r: r r r rt r r rd r r )r! r vnowrk r s r
drag Arcball.drag s $ULL$,,G :: !,T::>DZZ
KK T * 99Q?T ! DJ1qtQqT599T[[$#?@A,Q , = /
-r r c * [ R " U S US -
U- US U S -
U- S4[ R S9nUS US - US US - - nUS: a U[ R " U5 - nU$ [ R " SU-
5 US' U$ )z7Return unit sphere coordinates from window coordinates.r r8 r6 r r% r7 )r r r
r9 r )r r' r( vry s r
r8 r8 s
eAh*f4 Qi%(*f4!& 0A
!QqT AaD1I A3w TYYq\
H yyq!! Hr c [ R " U [ R SS9n[ R " U[ R SS9nX#[ R " X25 - - n[ U5 nU[
: a US S: a US- nX$- nU$ US S:X a% [ R " / SQ[ R S9$ [
US * US
S
/5 $ ) z*Return sphere point perpendicular to axis.Tr$ r7 r6 rc r% )r8 r r r r8 r )r r r
r rS rd r )r r rO r ry s r
r: r: s
E T:A
D
D9AUYYq_ AAA4x Q4#:
IA ts{{{9EMM:: 1qtQ' ((r c [ R " U [ R SS9n SnSnU H. n[ R " [ X5 U 5 nXS: d M* UnUnM0 U$ )z+Return axis, which arc is nearest to point.Fr$ Nrc )r r r
r r: )r r nearestmxr rk s r
r9 r9 sX KKU]] ?EG
B II/rm s :&9daA6&9s c [ R " U [ R SS9n Uc~ U R S:X a* [ R
" [ R " X 5 5 $ X - n [ R " [ R " XS95 n[ R
" X"5 U$ X - n [ R " XUS9 [ R
" X"5 g)al Return length, i.e. eucledian norm, of ndarray along axis.
>>> v = numpy.random.random(3)
>>> n = vector_norm(v)
>>> numpy.allclose(n, numpy.linalg.norm(v))
True
>>> v = numpy.random.rand(6, 5, 3)
>>> n = vector_norm(v, axis=-1)
>>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=2)))
True
>>> n = vector_norm(v, axis=1)
>>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1)))
True
>>> v = numpy.random.rand(5, 4, 3)
>>> n = numpy.empty((5, 3), dtype=numpy.float64)
>>> vector_norm(v, axis=1, out=n)
>>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1)))
True
>>> vector_norm([])
0.0
>>> vector_norm([1.0])
1.0
Tr$ Nr8 r )r out) r r r
ndimr9 r r
atleast_1dr )datar ro s r
rS rS s 2 ;;t5==t 99UYYt 23 3 uyy 9:
3
$s+
3 r c Ucd [ R " U [ R SS9n U R S:X a/ U [ R
" [ R " X 5 5 - n U $ O X La [ R " U SS9USS& Un [ R " [ R " X - U5 5 n[ R
" X35 Ub [ R " X15 nX- n Uc U $ g)a Return ndarray normalized by length, i.e. eucledian norm, along axis.
>>> v0 = numpy.random.random(3)
>>> v1 = unit_vector(v0)
>>> numpy.allclose(v1, v0 / numpy.linalg.norm(v0))
True
>>> v0 = numpy.random.rand(5, 4, 3)
>>> v1 = unit_vector(v0, axis=-1)
>>> v2 = v0 / numpy.expand_dims(numpy.sqrt(numpy.sum(v0*v0, axis=2)), 2)
>>> numpy.allclose(v1, v2)
True
>>> v1 = unit_vector(v0, axis=1)
>>> v2 = v0 / numpy.expand_dims(numpy.sqrt(numpy.sum(v0*v0, axis=1)), 1)
>>> numpy.allclose(v1, v2)
True
>>> v1 = numpy.empty((5, 4, 3), dtype=numpy.float64)
>>> unit_vector(v0, axis=1, out=v1)
>>> numpy.allclose(v1, v2)
True
>>> list(unit_vector([]))
[]
>>> list(unit_vector([1.0]))
[1.0]
NTr$ r8 Fr )
r r r
rp r9 r r rq r expand_dims)rr r ro lengths r
r r & s 4 {{{4u}}4@ 99> DIIeii 34 4DK ?[[E2CF
eii 4 8
9F JJv ""60ND
{ r c @ [ R R U 5 $ )zReturn array of random doubles in the half-open interval [0.0, 1.0).
>>> v = random_vector(10000)
>>> numpy.all(v >= 0.0) and numpy.all(v < 1.0)
True
>>> v0 = random_vector(10)
>>> v1 = random_vector(10)
>>> numpy.any(v0 == v1)
False
)r r )sizes r
random_vectorrx R s << t $$r c @ [ R R U 5 $ )aR Return inverse of square transformation matrix.
>>> M0 = random_rotation_matrix()
>>> M1 = inverse_matrix(M0.T)
>>> numpy.allclose(M1, numpy.linalg.inv(M0.T))
True
>>> for size in range(1, 7):
... M0 = numpy.random.rand(size, size)
... M1 = inverse_matrix(M0)
... if not numpy.allclose(M1, numpy.linalg.inv(M0)): print size
)r r) r r s r
inverse_matrixrz a s << F ##r c p [ R " S5 nU H n[ R " X5 nM U$ )zReturn concatenation of series of transformation matrices.
>>> M = numpy.random.rand(16).reshape((4, 4)) - 0.5
>>> numpy.allclose(M, concatenate_matrices(M))
True
>>> numpy.allclose(numpy.dot(M, M.T), concatenate_matrices(M, M.T))
True
r )r r r )matricesr r3 s r
concatenate_matricesr} q s. qA
IIaO Hr c [ R " U [ R SS9n X S - n [ R " U[ R SS9nXS - n[ R " X5 $ )zReturn True if two matrices perform same transformation.
>>> is_same_transform(numpy.identity(4), numpy.identity(4))
True
>>> is_same_transform(numpy.identity(4), random_rotation_matrix())
False
Tr$ r[ )r r r
allclose)matrix0matrix1s r
is_same_transformr sW kk' TBG t} Gkk' TBG t} G >>' ++r c [ U 5 n[ U5 H nU( a UR U5 ( a M" U( aI U[ 5 ; a [ 5 U [ 5 X%- ' O U( a [ R
" SU- 5 [
XE5 [ 5 U' M g! [ a% U( a [ R
" SU - 5 g gf = f)zTry import all public attributes from module into global namespace.
Existing attributes with name clashes are renamed with prefix.
Attributes starting with underscore are ignored by default.
Return True on successful import.
z No Python implementation of TzFailed to import module N)
__import__dir
startswithglobalswarningswarngetattr ImportError) module_namer prefixignoremoduleattrs r
_import_moduler s K(
KD$//&1179$/6yGIfm, MM"@4"GH %f 3GIdO D MM4{B C Ds B% %*CCrG )NN)NNF)F)NNNNN)FT)r )r T)T_py_r );rL
__future__r r r9 r
__docformat__r r r r" r4 r@ rK rP rV r_ ra rl ro rz r r r r r r r r r r r r r r r
r r objectr r8 r: r9 finfor& epsrd r r dictitemsr rS r rx rz r} r r r r r
r sY @GR &
2
9
4:)
X%#P"
J&%R 04/4;
|F8R1/h
>*+ZR8j CG #2
j 8c
L<
~7tB6r" ,
@>"
M P&R@< 6 q-f q-h
)
{{5 #
F
LF ,F06 F
LF ,F06 F LF !,F 17 F L F !, F 17 F
L F
!, F
17 F L
F !,
F 9E , , F :k&7&7&9:: $ N)X %
$
, r