def test_getangle_sho_datatypes(self):
"""
This test provides coverage of the getangle_sho function in pyCGM.py, defined as getangle_sho(axisP,axisD).
It checks that the resulting output from calling getangle_sho is correct for a list of ints, a numpy array of
ints, a list of floats, and a numpy array of floats.
"""
axisD = pyCGM.rotmat(0, 0, 0)
axisP_floats = pyCGM.rotmat(90, 0, 90)
axisP_ints = [[int(y) for y in x] for x in axisP_floats]
expected = [0, 90, 90]
# Check that calling getangle_sho on a list of ints yields the expected results
result_int_list = pyCGM.getangle_sho(axisP_ints, axisD)
np.testing.assert_almost_equal(result_int_list, expected, rounding_precision)
# Check that calling getangle_sho on a numpy array of ints yields the expected results
result_int_nparray = pyCGM.getangle_sho(np.array(axisP_ints, dtype='int'), np.array(axisD, dtype='int'))
np.testing.assert_almost_equal(result_int_nparray, expected, rounding_precision)
# Check that calling getangle_sho on a list of floats yields the expected results
result_float_list = pyCGM.getangle_sho(axisP_floats, axisD)
np.testing.assert_almost_equal(result_float_list, expected, rounding_precision)
# Check that calling getangle_sho on a numpy array of floats yields the expected results
result_float_nparray = pyCGM.getangle_sho(np.array(axisP_floats, dtype='float'), np.array(axisD, dtype='float'))
np.testing.assert_almost_equal(result_float_nparray, expected, rounding_precision)
def test_getPelangle(self, xRot, yRot, zRot, expected):
"""
This test provides coverage of the getPelangle function in pyCGM.py,
defined as getPelangle(axisP,axisD) where axisP is the proximal axis and axisD is the distal axis
getPelangle takes in as input two axes, axisP and axisD, and returns in degrees, the Euler angle
rotations required to rotate axisP to axisD as a list [alpha, beta, gamma]. getPelangle uses the YXZ
order of Euler rotations to calculate the angles. The rotation matrix is obtained by directly comparing
the vectors in axisP to those in axisD through dot products between different components
of each axis. axisP and axisD each have 3 components to their axis, x, y, and z.
The angles are calculated as follows:
.. math::
\[ \beta = \arctan2{((axisD_{z} \cdot axisP_{y}), \sqrt{(axisD_{z} \cdot axisP_{x})^2 + (axisD_{z} \cdot axisP_{z})^2}}) \]
\[ \alpha = \arctan2{((axisD_{z} \cdot axisP_{x}), axisD_{z} \cdot axisP_{z})} \]
\[ \gamma = \arctan2{((axisD_{x} \cdot axisP_{y}), axisD_{y} \cdot axisP_{y})} \]
This test calls pyCGM.rotmat() to create axisP with an x, y, and z rotation defined in the parameters.
It then calls pyCGM.getHeadangle() with axisP and axisD, which was created with no rotation in the x, y or z
direction. This result is then compared to the expected result. The results from this test will be in the
YXZ order, meaning that a parameter with an inputed x rotation will have a result with the same angle in
the z direction. The exception to this is x rotations. An x rotation of 90, 30, -30, 120, -120, 180
degrees results in a -90, -30, 30, -6, 60, 0 degree angle in the y direction respectively. A x rotation or
120, -120, or 180 also results in a 180 degree rotation in the x and z angles.
"""
# Create axisP as a rotatinal matrix using the x, y, and z rotations given in testcase
axisP = pyCGM.rotmat(xRot, yRot, zRot)
axisD = pyCGM.rotmat(0, 0, 0)
result = pyCGM.getPelangle(axisP, axisD)
np.testing.assert_almost_equal(result, expected, rounding_precision)
def test_getangle_spi(self, xRot, yRot, zRot, expected):
"""
This test provides coverage of the getangle_spi function in pyCGM.py,
defined as getangle_spi(axisP,axisD) where axisP is the proximal axis and axisD is the distal axis
getangle_spi takes in as input two axes, axisP and axisD, and returns in degrees, the Euler angle
rotations required to rotate axisP to axisD as a list [beta, gamma, alpha]. getangle_spi uses the XZX
order of Euler rotations to calculate the angles. The rotation matrix is obtained by directly comparing
the vectors in axisP to those in axisD through dot products between different components
of each axis. axisP and axisD each have 3 components to their axis, x, y, and z.
The angles are calculated as follows:
.. math::
\[ alpha = \arcsin{(axisD_{y} \cdot axisP_{z})} \]
\[ gamma = \arcsin{(-(axisD_{y} \cdot axisP_{x}) / \cos{\alpha})} \]
\[ beta = \arcsin{(-(axisD_{x} \cdot axisP_{z}) / \cos{\alpha})} \]
This test calls pyCGM.rotmat() to create axisP with an x, y, and z rotation defined in the parameters.
It then calls pyCGM.getangle_spi() with axisP and axisD, which was created with no rotation in the
x, y or z direction. This result is then compared to the expected result. The results from this test will
be in the YZX order, meaning that a parameter with an inputed x rotation will have a result with the same
angle in the z direction. The only exception to this is a 120, -120, or 180 degree Y rotation. The exception
to this is that 120, -120, and 180 degree rotations end up with 60, -60, and 0 degree angles respectively.
"""
# Create axisP as a rotatinal matrix using the x, y, and z rotations given in testcase
axisP = pyCGM.rotmat(xRot, yRot, zRot)
axisD = pyCGM.rotmat(0, 0, 0)
result = pyCGM.getangle_spi(axisP, axisD)
np.testing.assert_almost_equal(result, expected, rounding_precision)
def test_rotmat_datatypes(self):
"""
This test provides coverage of the rotmat function in pyCGM.py, defined as rotmat(x, y, z)
where x, y, and z are all floats that represent the angle of rotation in a particular dimension.
This test checks that the resulting output from calling rotmat is correct when called with ints or floats.
"""
result_int = pyCGM.rotmat(0, 150, -30)
result_float = pyCGM.rotmat(0.0, 150.0, -30.0)
expected = [[-0.75, -0.4330127, 0.5], [-0.5, 0.8660254, 0],
[-0.4330127, -0.25, -0.8660254]]
np.testing.assert_almost_equal(result_int, expected,
rounding_precision)
np.testing.assert_almost_equal(result_float, expected,
rounding_precision)
def test_getangle(self, xRot, yRot, zRot, expected):
"""
This test provides coverage of the getangle function in pyCGM.py,
defined as getangle(axisP,axisD) where axisP is the proximal axis and axisD is the distal axis
getangle takes in as input two axes, axisP and axisD, and returns in degrees, the Euler angle
rotations required to rotate axisP to axisD as a list [beta, alpha, gamma]. getangle uses the YXZ
order of Euler rotations to calculate the angles. The rotation matrix is obtained by directly comparing
the vectors in axisP to those in axisD through dot products between different components
of each axis. axisP and axisD each have 3 components to their axis, x, y, and z. Since arcsin
is being used, the function checks wether the angle alpha is between -pi/2 and pi/2.
The angles are calculated as follows:
.. math::
\[ \alpha = \arcsin{(-axisD_{z} \cdot axisP_{y})} \]
If alpha is between -pi/2 and pi/2
.. math::
\[ \beta = \arctan2{((axisD_{z} \cdot axisP_{x}), axisD_{z} \cdot axisP_{z})} \]
\[ \gamma = \arctan2{((axisD_{y} \cdot axisP_{y}), axisD_{x} \cdot axisP_{y})} \]
Otherwise
.. math::
\[ \beta = \arctan2{(-(axisD_{z} \cdot axisP_{x}), axisD_{z} \cdot axisP_{z})} \]
\[ \gamma = \arctan2{(-(axisD_{y} \cdot axisP_{y}), axisD_{x} \cdot axisP_{y})} \]
This test calls pyCGM.rotmat() to create axisP with an x, y, and z rotation defined in the parameters.
It then calls pyCGM.getangle() with axisP and axisD, which was created with no rotation in the x, y or z
direction. This result is then compared to the expected result. The results from this test will be in the
YXZ order, meaning that a parameter with an inputed x rotation will have a result with the same angle in
the z direction. There is also an additional 90 degree angle in the z direction if there was no z rotation.
If there was a z rotation than there will be a different angle in the z direction. A z rotation of 90, 30, -30,
120, -120, 180 degrees results in a 0, 60, 120, -30, -150, -90 degree angle in the z direction respectively.
"""
# Create axisP as a rotatinal matrix using the x, y, and z rotations given in testcase
axisP = pyCGM.rotmat(xRot, yRot, zRot)
axisD = pyCGM.rotmat(0, 0, 0)
result = pyCGM.getangle(axisP, axisD)
np.testing.assert_almost_equal(result, expected, rounding_precision)
def test_rotmat(self, x, y, z, expected):
"""
This test provides coverage of the rotmat function in pyCGM.py, defined as rotmat(x, y, z)
where x, y, and z are all floats that represent the angle of rotation in a particular dimension.
This test takes 4 parameters:
x: angle to be rotated in the x axis
y: angle to be rotated in the y axis
z: angle to be rotated in the z axis
expected: the expected rotation matrix from calling rotmat on x, y, and z. This will be a transformation
matrix that can be used to perform a rotation in the x, y, and z directions at the values inputted.
"""
result = pyCGM.rotmat(x, y, z)
np.testing.assert_almost_equal(result, expected, rounding_precision)
