Esempio n. 1
0
def test_matrix2euler_all_combinations():
    for matrix in (test_matrix_single, test_matrix_multiple):
        for axes in valid_axes:
            for intrinsic in (True, False):
                for positive_ccw in (True, False):
                    result = matrix2euler(matrix,
                                          axes=axes,
                                          intrinsic=True,
                                          right_handed_rotation=True)
                    assert result.shape[-1] == 3
Esempio n. 2
0
def matrix2euler(rotation_matrices):
    """
    convert euler matrices to angles
    """
    # invert them so that we return matrices which transform reference onto particle
    rotation_matrices = rotation_matrices.transpose((0, 2, 1))

    euler_angles = eulerangles.matrix2euler(rotation_matrices,
                                            axes='zyz',
                                            intrinsic=True,
                                            right_handed_rotation=True)
    return euler_angles
Esempio n. 3
0
def test_matrix2euler_relion():
    relion_matrix = np.array([[-0.99985746, 0.00734648, -0.01520186],
                              [-0.00755692, -0.99987577, 0.01383262],
                              [-0.01509835, 0.01394553, 0.99978876]])
    relion_eulers = [137.7000, 1.1777, 42.7270]
    relion_meta = get_conversion_metadata('relion')

    result_eulers = matrix2euler(
        relion_matrix,
        axes=relion_meta.axes,
        intrinsic=relion_meta.intrinsic,
        right_handed_rotation=relion_meta.right_handed_rotation)

    assert_array_almost_equal(relion_eulers, result_eulers, decimal=4)
Esempio n. 4
0
def test_matrix2euler_dynamo():
    dynamo_matrix = np.array([[-0.0173, -0.5477, 0.8365],
                              [0.9012, -0.3709, -0.2241],
                              [0.4330, 0.7500, 0.5000]])
    dynamo_eulers = np.array([30, 60, 75])
    dynamo_meta = get_conversion_metadata('dynamo')

    result_eulers = matrix2euler(
        dynamo_matrix,
        axes=dynamo_meta.axes,
        intrinsic=dynamo_meta.intrinsic,
        right_handed_rotation=dynamo_meta.right_handed_rotation)

    assert_array_almost_equal(dynamo_eulers, result_eulers, decimal=2)
def test_all_valid_axes():
    eulers = [10, 20, 30]
    for axes in valid_axes:
        rotation_matrix = euler2matrix(eulers,
                                       axes=axes,
                                       intrinsic=False,
                                       right_handed_rotation=True)

        result_eulers = matrix2euler(rotation_matrix,
                                     axes=axes,
                                     right_handed_rotation=True,
                                     intrinsic=False)
        result_rotation_matrix = euler2matrix(result_eulers,
                                              axes=axes,
                                              intrinsic=False,
                                              right_handed_rotation=True)

        assert_array_almost_equal(eulers, result_eulers)
        assert_array_almost_equal(rotation_matrix, result_rotation_matrix)