def rotate(self, angle, axis=OUT, **kwargs):
curr_rot_T = self.get_inverse_camera_rotation_matrix()
added_rot_T = rotation_matrix_transpose(angle, axis)
new_rot_T = np.dot(curr_rot_T, added_rot_T)
Fz = new_rot_T[2]
phi = np.arccos(Fz[2])
theta = angle_of_vector(Fz[:2]) + PI / 2
partial_rot_T = np.dot(
rotation_matrix_transpose(phi, RIGHT),
rotation_matrix_transpose(theta, OUT),
)
gamma = angle_of_vector(np.dot(partial_rot_T, new_rot_T.T)[:, 0])
self.set_euler_angles(theta, phi, gamma)
return self
def rotate(self, angle, axis=OUT, **kwargs):
rot_matrix_T = rotation_matrix_transpose(angle, axis)
self.apply_points_function_about_point(
lambda points: np.dot(points, rot_matrix_T),
**kwargs
)
return self
def path(start_points, end_points, alpha):
vects = end_points - start_points
centers = start_points + 0.5 * vects
if arc_angle != np.pi:
centers += np.cross(unit_axis, vects / 2.0) / math.tan(arc_angle / 2)
rot_matrix_T = rotation_matrix_transpose(alpha * arc_angle, unit_axis)
return centers + np.dot(start_points - centers, rot_matrix_T)
def set_points_by_ends(self, start, end, buff=0, path_arc=0):
# Find the right tip length and thickness
vect = end - start
length = max(get_norm(vect), 1e-8)
thickness = self.thickness
w_ratio = fdiv(self.max_width_to_length_ratio, fdiv(thickness, length))
if w_ratio < 1:
thickness *= w_ratio
tip_width = self.tip_width_ratio * thickness
tip_length = tip_width / (2 * np.tan(self.tip_angle / 2))
t_ratio = fdiv(self.max_tip_length_to_length_ratio,
fdiv(tip_length, length))
if t_ratio < 1:
tip_length *= t_ratio
tip_width *= t_ratio
# Find points for the stem
if path_arc == 0:
points1 = (length - tip_length) * np.array(
[RIGHT, 0.5 * RIGHT, ORIGIN])
points1 += thickness * UP / 2
points2 = points1[::-1] + thickness * DOWN
else:
# Solve for radius so that the tip-to-tail length matches |end - start|
a = 2 * (1 - np.cos(path_arc))
b = -2 * tip_length * np.sin(path_arc)
c = tip_length**2 - length**2
R = (-b + np.sqrt(b**2 - 4 * a * c)) / (2 * a)
# Find arc points
points1 = Arc.create_quadratic_bezier_points(path_arc)
points2 = np.array(points1[::-1])
points1 *= (R + thickness / 2)
points2 *= (R - thickness / 2)
if path_arc < 0:
tip_length *= -1
rot_T = rotation_matrix_transpose(PI / 2 - path_arc, OUT)
for points in points1, points2:
points[:] = np.dot(points, rot_T)
points += R * DOWN
self.set_points(points1)
# Tip
self.add_line_to(tip_width * UP / 2)
self.add_line_to(tip_length * LEFT)
self.tip_index = len(self.get_points()) - 1
self.add_line_to(tip_width * DOWN / 2)
self.add_line_to(points2[0])
# Close it out
self.append_points(points2)
self.add_line_to(points1[0])
if length > 0:
# Final correction
super().scale(length / self.get_length())
self.rotate(angle_of_vector(vect) - self.get_angle())
self.shift(start - self.get_start())
self.refresh_triangulation()
