Beispiel #1
0
 def axis(self):
     """Vector3d : the axis of rotation."""
     axis = Vector3d(
         np.stack((self.b.data, self.c.data, self.d.data), axis=-1))
     axis[self.a.data < -1e-6] = -axis[self.a.data < -1e-6]
     axis[axis.norm.data == 0] = Vector3d.zvector() * np.sign(
         self.a[axis.norm.data == 0].data)
     axis.data = axis.data / axis.norm.data[..., np.newaxis]
     return axis
Beispiel #2
0
 def __init__(self, theta_grid: S1Grid, rho_grid: S1Grid):
     self.theta_grid = theta_grid
     self.rho_grid = rho_grid
     theta = np.tile(theta_grid.points, rho_grid.points.shape)
     rho = rho_grid.points
     v = Vector3d.from_polar(theta, rho)
     self.points = v
Beispiel #3
0
 def get_plot_data(self):
     from texpy.vector import Vector3d
     theta = np.linspace(0, 2 * np.pi + 1e-9, 361)
     rho = np.linspace(0, np.pi, 181)
     theta, rho = np.meshgrid(theta, rho)
     g = Vector3d.from_polar(rho, theta)
     n = Rodrigues.from_rotation(self).norm.data[:, np.newaxis, np.newaxis]
     if n.size == 0:
         return Rotation.from_neo_euler(AxAngle.from_axes_angles(g, np.pi))
     d = (-self.axis).dot_outer(g.unit).data
     x = n * d
     x = 2 * np.arctan(x**-1)
     x[x < 0] = np.pi
     x = np.min(x, axis=0)
     r = Rotation.from_neo_euler(AxAngle.from_axes_angles(g.unit, x))
     return r
Beispiel #4
0
    def from_axes_angles(cls, axes, angles):
        """Create new AxAngle object explicitly from the given axes and angles.

        Parameters
        ----------
        axes : Vector3d or array_like
            The axis of rotation.
        angles : array_like
            The angle of rotation, in radians.

        Returns
        -------
        AxAngle

        """
        axes = Vector3d(axes).unit
        angles = np.array(angles)
        axangle_data = angles[..., np.newaxis] * axes.data
        return cls(axangle_data)
Beispiel #5
0
def vector(request):
    return Vector3d(request.param)
Beispiel #6
0
]

angles = [
    -2 * np.pi,
    -5 * np.pi / 6,
    -np.pi / 3,
    0,
    np.pi / 12,
    np.pi / 3,
    3 * np.pi / 4,
    2 * np.pi,
    np.pi / 7,
]

axangles = [
    np.array(angle) * Vector3d(axis).unit for axis in axes for angle in angles
]
axangles += [
    np.array(angle) * Vector3d(axis).unit
    for axis in itertools.combinations_with_replacement(axes, 2)
    for angle in itertools.combinations_with_replacement(angles, 2)
]


@pytest.fixture(params=axangles[:100])
def axangle(request):
    return AxAngle(request.param.data)


def test_angle(axangle):
    assert np.allclose(axangle.angle.data, axangle.norm.data)
Beispiel #7
0
 def axis(self):
     """Vector3d : the axis of rotation."""
     return Vector3d(self.unit)
Beispiel #8
0
 def axis(self):
     return Vector3d(self.unit)
Beispiel #9
0
def something(request):
    return Vector3d(request.param)
Beispiel #10
0
def test_perpendicular(vector: Vector3d):
    assert np.allclose(vector.dot(vector.perpendicular).data, 0)
Beispiel #11
0
def test_rotate(vector, rotation, expected):
    r = Vector3d(vector).rotate(Vector3d.zvector(), rotation)
    assert isinstance(r, Vector3d)
    assert np.allclose(r.data, expected)
Beispiel #12
0
def test_zero(shape):
    v = Vector3d.zero(shape)
    assert v.shape == shape
    assert v.data.shape[-1] == v.dim
Beispiel #13
0
def test_polar(theta, phi, r, expected):
    assert np.allclose(Vector3d.from_polar(theta, phi, r).data, expected.data, atol=1e-5)
Beispiel #14
0
@pytest.fixture(params=singles)
def something(request):
    return Vector3d(request.param)


@pytest.fixture(params=numbers)
def number(request):
    return request.param


def test_neg(vector):
    assert np.all((-vector).data == -(vector.data))


@pytest.mark.parametrize('vector, other, expected', [
    ([1, 2, 3], Vector3d([[1, 2, 3], [-3, -2, -1]]), [[2, 4, 6], [-2, 0, 2]]),
    ([1, 2, 3], Scalar([4]), [5, 6, 7]),
    ([1, 2, 3], 0.5, [1.5, 2.5, 3.5]),
    ([1, 2, 3], [-1, 2], [[0, 1, 2], [3, 4, 5]]),
    ([1, 2, 3], np.array([-1, 1]), [[0, 1, 2], [2, 3, 4]]),
    pytest.param([1, 2, 3], 'dracula', None, marks=pytest.mark.xfail),
], indirect=['vector'])
def test_add(vector, other, expected):
    s1 = vector + other
    s2 = other + vector
    assert np.allclose(s1.data, expected)
    assert np.allclose(s1.data, s2.data)


@pytest.mark.parametrize('vector, other, expected', [
    ([1, 2, 3], Vector3d([[1, 2, 3], [-3, -2, -1]]), [[0, 0, 0], [4, 4, 4]]),
Beispiel #15
0
def test_multiply_vector(quaternion, vector, expected):
    q = Quaternion(quaternion)
    v = Vector3d(vector)
    v_new = q * v
    assert np.allclose(v_new.data, expected)