def test_getankleangle_datatypes(self):
"""
This test provides coverage of the getankleangle function in pycgmStatic.py, defined as getankleangle(axisP, axisD)
This test checks that the resulting output from calling getankleangle is correct when called with a list of ints,
a numpy array of ints, a list of floats, and a numpy array of floats.
"""
axisD = pycgmStatic.rotmat(0, 0, 0)
axisP_floats = pycgmStatic.rotmat(90, 90, 90)
axisP_ints = [[int(y) for y in x] for x in axisP_floats]
expected_results = [0, -1.570796, 0]
# Check that calling getankleangle on a list of ints yields the expected results
result_int_list = pycgmStatic.getankleangle(axisP_ints, axisD)
np.testing.assert_almost_equal(result_int_list, expected_results, rounding_precision)
# Check that calling getankleangle on a numpy array of ints yields the expected results
result_int_nparray = pycgmStatic.getankleangle(np.array(axisP_ints, dtype='int'), np.array(axisD, dtype='int'))
np.testing.assert_almost_equal(result_int_nparray, expected_results, rounding_precision)
# Check that calling getankleangle on a list of floats yields the expected results
result_float_list = pycgmStatic.getankleangle(axisP_floats, axisD)
np.testing.assert_almost_equal(result_float_list, expected_results, rounding_precision)
# Check that calling getankleangle on a numpy array of floats yields the expected results
result_float_nparray = pycgmStatic.getankleangle(np.array(axisP_floats, dtype='float'), np.array(axisD, dtype='float'))
np.testing.assert_almost_equal(result_float_nparray, expected_results, rounding_precision)
def test_getankleangle(self, xRot, yRot, zRot, expected_results):
"""
This test provides coverage of the getankleangle function in pycgmStatic.py, defined as getankleangle(axisP, axisD)
This test takes 3 parameters:
axisP: the unit vector of axisP, the position of the proximal axis
axisD: the unit vector of axisD, the position of the distal axis
expected_results: the expected result from calling getankleangle on axisP and axisD. This returns the x, y, z angles
from a XYZ Euler angle calculation from a rotational matrix. This rotational matrix is calculated by matrix
multiplication of axisD and the inverse of axisP. This angle is in radians, not degrees.
The x, y, and z angles are defined as:
.. math::
\[ x = \arctan{\frac{M[2][1]}{\sqrt{M[2][0]^2 + M[2][2]^2}}} \]
\[ y = \arctan{\frac{-M[2][0]}{M[2][2]}} \]
\[ z = \arctan{\frac{-M[0][1]}{M[1][1]}} \]
where M is the rotation matrix produced from multiplying axisD and :math:`axisP^{-1}`
This test ensures that:
- A rotation in one axis will only effect the resulting angle in the corresponding axes
- A rotation in multiple axes can effect the angles in other axes due to XYZ order
"""
# Create axisP as a rotatinal matrix using the x, y, and z rotations given
axisP = pycgmStatic.rotmat(xRot, yRot, zRot)
axisD = pycgmStatic.rotmat(0, 0, 0)
result = pycgmStatic.getankleangle(axisP, axisD)
np.testing.assert_almost_equal(result, expected_results, rounding_precision)
def test_headoffCalc(self, xRot, yRot, zRot, expected_results):
"""
This test provides coverage of the headoffCalc function in pycgmStatic.py, defined as headoffCalc(axisP, axisD)
This test takes 3 parameters:
axisP: the unit vector of axisP, the position of the proximal axis
axisD: the unit vector of axisD, the position of the distal axis
expected_results: the expected result from calling headoffCalc on axisP and axisD. This returns the y-rotation
from a rotational matrix calculated by matrix multiplication of axisD and the inverse of axisP. This angle is in
radians, not degrees.
The y angle is defined as:
.. math::
\[ result = \arctan{\frac{M[0][2]}{M[2][2]}} \]
where M is the rotation matrix produced from multiplying axisD and :math:`axisP^{-1}`
This unit test ensures that:
- Rotations in only the x or z direction will return a angle of 0
- Rotations in only the y direction will return the same angle
- Rotations in multiple axes will return a value based off of the all the rotations used in the rotation matrix
"""
# Create axisP as a rotational matrix using the x, y, and z rotations given
axisP = pycgmStatic.rotmat(xRot, yRot, zRot)
axisD = pycgmStatic.rotmat(0, 0, 0)
result = pycgmStatic.headoffCalc(axisP, axisD)
np.testing.assert_almost_equal(result, expected_results, rounding_precision)
def test_rotmat_datatypes(self):
"""
This test provides coverage of the rotmat function in pycgmStatic.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 = pycgmStatic.rotmat(0, 150, -30)
result_float = pycgmStatic.rotmat(0.0, 150.0, -30.0)
expected_results = [[-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_results, rounding_precision)
np.testing.assert_almost_equal(result_float, expected_results, rounding_precision)
def test_rotmat(self, x, y, z, expected_results):
"""
This test provides coverage of the rotmat function in pycgmStatic.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_results: 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 = pycgmStatic.rotmat(x, y, z)
np.testing.assert_almost_equal(result, expected_results, rounding_precision)