def construct(self):
# Set objets
theta = ValueTracker(self.theta)
line_1 = Line(ORIGIN, RIGHT * self.lines_size, color=self.line_1_color)
line_2 = Line(ORIGIN, RIGHT * self.lines_size, color=self.line_2_color)
line_2.rotate(theta.get_value(), about_point=ORIGIN)
line_2.add_updater(lambda m: m.set_angle(theta.get_value()))
angle = Arc(radius=self.radius,
start_angle=line_1.get_angle(),
angle=line_2.get_angle(),
color=self.radius_color)
# Show the objects
self.play(*[ShowCreation(obj) for obj in [line_1, line_2, angle]])
# Set update function to angle
angle.add_updater(lambda m: m.become(
Arc(radius=self.radius,
start_angle=line_1.get_angle(),
angle=line_2.get_angle(),
color=self.radius_color)))
# Remember to add the objects again to the screen
# when you add the add_updater method.
self.add(angle)
self.play(theta.increment_value, self.increment_theta)
# self.play(theta.set_value,self.final_theta)
self.wait()
def __init__(self, *args, **kwargs):
Camera.__init__(self, *args, **kwargs)
self.phi_tracker = ValueTracker(self.phi)
self.theta_tracker = ValueTracker(self.theta)
self.distance_tracker = ValueTracker(self.distance)
self.gamma_tracker = ValueTracker(self.gamma)
self.light_source = Point(self.light_source_start_point)
self.frame_center = Point(self.frame_center)
self.fixed_orientation_mobjects = dict()
self.fixed_in_frame_mobjects = set()
self.reset_rotation_matrix()
def construct(self):
theta = ValueTracker(PI / 2)
line_1 = Line(ORIGIN, RIGHT * 3, color=RED)
line_2 = Line(ORIGIN, RIGHT * 3, color=GREEN)
line_2.rotate(theta.get_value(), about_point=ORIGIN)
line_2.add_updater(lambda m: m.set_angle(theta.get_value()))
self.add(line_1, line_2)
self.play(theta.increment_value, PI / 2)
self.wait()
def __init__(self, *args, **kwargs):
Camera.__init__(self, *args, **kwargs)
self.phi_tracker = ValueTracker(self.phi)
self.theta_tracker = ValueTracker(self.theta)
self.distance_tracker = ValueTracker(self.distance)
self.gamma_tracker = ValueTracker(self.gamma)
self.light_source = Point(self.light_source_start_point)
self.frame_center = Point(self.frame_center)
self.fixed_orientation_mobjects = dict()
self.fixed_in_frame_mobjects = set()
self.reset_rotation_matrix()
def __init__(self, **kwargs):
"""
frame is a Mobject, (should almost certainly be a rectangle)
determining which region of space the camera displys
"""
digest_config(self, kwargs)
self.init_vars()
if self.frame is None:
self.frame = CameraFrame(
default_frame_stroke_width=self.default_frame_stroke_width)
Cam.__init__(self, **kwargs)
# Camer3D
if self.C3D:
self.phi_tracker = ValueTracker(self.phi)
self.theta_tracker = ValueTracker(self.theta)
self.distance_tracker = ValueTracker(self.distance)
self.gamma_tracker = ValueTracker(self.gamma)
self.light_source = Point(self.light_source_start_point)
self.frame_center = Point(self.frame_center)
self.fixed_orientation_mobjects = dict()
self.fixed_in_frame_mobjects = set()
self.reset_rotation_matrix()
def set_value(self, value):
self.assert_value(value)
self.set_value_anim(value)
return ValueTracker.set_value(self, value)
class ThreeDCamera(Camera):
CONFIG = {
"shading_factor": 0.2,
"distance": 20.0,
"default_distance": 5.0,
"phi": 0, # Angle off z axis
"theta": -90 * DEGREES, # Rotation about z axis
"gamma": 0, # Rotation about normal vector to camera
"light_source_start_point": 9 * DOWN + 7 * LEFT + 10 * OUT,
"frame_center": ORIGIN,
"should_apply_shading": True,
"exponential_projection": False,
"max_allowable_norm": 3 * FRAME_WIDTH,
}
def __init__(self, *args, **kwargs):
Camera.__init__(self, *args, **kwargs)
self.phi_tracker = ValueTracker(self.phi)
self.theta_tracker = ValueTracker(self.theta)
self.distance_tracker = ValueTracker(self.distance)
self.gamma_tracker = ValueTracker(self.gamma)
self.light_source = Point(self.light_source_start_point)
self.frame_center = Point(self.frame_center)
self.fixed_orientation_mobjects = dict()
self.fixed_in_frame_mobjects = set()
self.reset_rotation_matrix()
def capture_mobjects(self, mobjects, **kwargs):
self.reset_rotation_matrix()
Camera.capture_mobjects(self, mobjects, **kwargs)
def get_value_trackers(self):
return [
self.phi_tracker,
self.theta_tracker,
self.distance_tracker,
self.gamma_tracker,
]
def modified_rgbas(self, vmobject, rgbas):
if not self.should_apply_shading:
return rgbas
if vmobject.shade_in_3d and (vmobject.get_num_points() > 0):
light_source_point = self.light_source.points[0]
if len(rgbas) < 2:
shaded_rgbas = rgbas.repeat(2, axis=0)
else:
shaded_rgbas = np.array(rgbas[:2])
shaded_rgbas[0, :3] = get_shaded_rgb(
shaded_rgbas[0, :3],
get_3d_vmob_start_corner(vmobject),
get_3d_vmob_start_corner_unit_normal(vmobject),
light_source_point,
)
shaded_rgbas[1, :3] = get_shaded_rgb(
shaded_rgbas[1, :3],
get_3d_vmob_end_corner(vmobject),
get_3d_vmob_end_corner_unit_normal(vmobject),
light_source_point,
)
return shaded_rgbas
return rgbas
def get_stroke_rgbas(self, vmobject, background=False):
return self.modified_rgbas(vmobject,
vmobject.get_stroke_rgbas(background))
def get_fill_rgbas(self, vmobject):
return self.modified_rgbas(vmobject, vmobject.get_fill_rgbas())
def get_mobjects_to_display(self, *args, **kwargs):
mobjects = Camera.get_mobjects_to_display(self, *args, **kwargs)
rot_matrix = self.get_rotation_matrix()
def z_key(mob):
if not (hasattr(mob, "shade_in_3d") and mob.shade_in_3d):
return np.inf
# Assign a number to a three dimensional mobjects
# based on how close it is to the camera
return np.dot(mob.get_z_index_reference_point(), rot_matrix.T)[2]
return sorted(mobjects, key=z_key)
def get_phi(self):
return self.phi_tracker.get_value()
def get_theta(self):
return self.theta_tracker.get_value()
def get_distance(self):
return self.distance_tracker.get_value()
def get_gamma(self):
return self.gamma_tracker.get_value()
def get_frame_center(self):
return self.frame_center.points[0]
def set_phi(self, value):
self.phi_tracker.set_value(value)
def set_theta(self, value):
self.theta_tracker.set_value(value)
def set_distance(self, value):
self.distance_tracker.set_value(value)
def set_gamma(self, value):
self.gamma_tracker.set_value(value)
def set_frame_center(self, point):
self.frame_center.move_to(point)
def reset_rotation_matrix(self):
self.rotation_matrix = self.generate_rotation_matrix()
def get_rotation_matrix(self):
return self.rotation_matrix
def generate_rotation_matrix(self):
phi = self.get_phi()
theta = self.get_theta()
gamma = self.get_gamma()
matrices = [
rotation_about_z(-theta - 90 * DEGREES),
rotation_matrix(-phi, RIGHT),
rotation_about_z(gamma),
]
result = np.identity(3)
for matrix in matrices:
result = np.dot(matrix, result)
return result
def project_points(self, points):
frame_center = self.get_frame_center()
distance = self.get_distance()
rot_matrix = self.get_rotation_matrix()
points = points - frame_center
points = np.dot(points, rot_matrix.T)
zs = points[:, 2]
for i in 0, 1:
if self.exponential_projection:
# Proper projedtion would involve multiplying
# x and y by d / (d-z). But for points with high
# z value that causes weird artifacts, and applying
# the exponential helps smooth it out.
factor = np.exp(zs / distance)
lt0 = zs < 0
factor[lt0] = (distance / (distance - zs[lt0]))
else:
factor = (distance / (distance - zs))
factor[(distance - zs) < 0] = 10**6
# clip_in_place(factor, 0, 10**6)
points[:, i] *= factor
points = points + frame_center
return points
def project_point(self, point):
return self.project_points(point.reshape((1, 3)))[0, :]
def transform_points_pre_display(self, mobject, points):
fixed_orientation = mobject in self.fixed_orientation_mobjects
fixed_in_frame = mobject in self.fixed_in_frame_mobjects
if fixed_in_frame:
return points
if fixed_orientation:
# center = center_of_mass(points)
center_func = self.fixed_orientation_mobjects[mobject]
center = center_func()
new_center = self.project_point(center)
return points + (new_center - center)
else:
return self.project_points(points)
def add_fixed_orientation_mobjects(self,
*mobjects,
use_static_center_func=False,
center_func=None):
# This prevents the computation of mobject.get_center
# every single time a projetion happens
def get_static_center_func(mobject):
point = mobject.get_center()
return (lambda: point)
for mobject in mobjects:
if center_func:
func = center_func
elif use_static_center_func:
func = get_static_center_func(mobject)
else:
func = mobject.get_center
for submob in mobject.get_family():
self.fixed_orientation_mobjects[submob] = func
def add_fixed_in_frame_mobjects(self, *mobjects):
for mobject in self.extract_mobject_family_members(mobjects):
self.fixed_in_frame_mobjects.add(mobject)
def remove_fixed_orientation_mobjects(self, *mobjects):
for mobject in self.extract_mobject_family_members(mobjects):
if mobject in self.fixed_orientation_mobjects:
self.fixed_orientation_mobjects.remove(mobject)
def remove_fixed_in_frame_mobjects(self, *mobjects):
for mobject in self.extract_mobject_family_members(mobjects):
if mobject in self.fixed_in_frame_mobjects:
self.fixed_in_frame_mobjects.remove(mobject)
class Camera(Cam):
"""
Stays in line with the height, width and position of it's 'frame', which is a Rectangle
"""
CONFIG = {
"fixed_dimension": 0, # width
"default_frame_stroke_color": WHITE,
"default_frame_stroke_width": 0,
"frame": None,
"C3D": False,
# Camera3D
"shading_factor": 0.2,
"distance": 20.0,
"default_distance": 5.0,
"phi": 0, # Angle off z axis
"theta": -90 * DEGREES, # Rotation about z axis
"gamma": 0, # Rotation about normal vector to camera
"light_source_start_point": 9 * DOWN + 7 * LEFT + 10 * OUT,
"frame_center": [0, 0, 0], # ORIGIN,
"should_apply_shading": True,
"exponential_projection": False,
"max_allowable_norm": 3 * FRAME_WIDTH,
}
def __init__(self, **kwargs):
"""
frame is a Mobject, (should almost certainly be a rectangle)
determining which region of space the camera displys
"""
digest_config(self, kwargs)
self.init_vars()
if self.frame is None:
self.frame = CameraFrame(
default_frame_stroke_width=self.default_frame_stroke_width)
Cam.__init__(self, **kwargs)
# Camer3D
if self.C3D:
self.phi_tracker = ValueTracker(self.phi)
self.theta_tracker = ValueTracker(self.theta)
self.distance_tracker = ValueTracker(self.distance)
self.gamma_tracker = ValueTracker(self.gamma)
self.light_source = Point(self.light_source_start_point)
self.frame_center = Point(self.frame_center)
self.fixed_orientation_mobjects = dict()
self.fixed_in_frame_mobjects = set()
self.reset_rotation_matrix()
def init_vars(self):
self.C3D = vars(self)['C3D']
self.frame = vars(self)['frame']
self.phi = vars(self)['phi']
self.theta = vars(self)['theta']
self.distance = vars(self)['distance']
self.gamma = vars(self)['gamma']
self.light_source_start_point = vars(self)['light_source_start_point']
self.should_apply_shading = vars(self)['should_apply_shading']
self.exponential_projection = vars(self)['exponential_projection']
self.gamma = vars(self)['gamma']
self.default_frame_stroke_width = vars(
self)['default_frame_stroke_width']
# TODO, make these work for a rotated frame
# <--2D
def get_frame_height(self):
if not self.C3D:
return self.frame.get_height()
else:
return Cam.get_frame_height(self)
def get_frame_width(self):
if not self.C3D:
return self.frame.get_width()
else:
return Cam.get_frame_width(self)
def get_frame_center(self):
if not self.C3D:
return self.frame.get_center()
else:
# return Cam.get_frame_center(self)
return self.frame_center.points[0]
def set_frame_height(self, frame_height):
if not self.C3D:
self.frame.stretch_to_fit_height(frame_height)
else:
Cam.set_frame_height(self, frame_height)
def set_frame_width(self, frame_width):
if not self.C3D:
self.frame.stretch_to_fit_width(frame_width)
else:
Cam.set_frame_width(self, frame_width)
def set_frame_center(self, frame_center):
if not self.C3D:
self.frame.move_to(frame_center)
else:
# Cam.set_frame_center(self, frame_center)#point
self.frame_center.move_to(frame_center) # point
# 2D-->
# Since the frame can be moving around, the cairo
# context used for updating should be regenerated
# at each frame. So no caching.
def get_cached_cairo_context(self, pixel_array):
if not self.C3D:
return None
else:
return Cam.get_cached_cairo_context(self, pixel_array)
def cache_cairo_context(self, pixel_array, ctx):
if not self.C3D:
pass
else:
Cam.cache_cairo_context(self, pixel_array, ctx)
# def reset_frame_center(self):
# self.frame_center = self.frame.get_center()
# def realign_frame_shape(self):
# height, width = self.frame_shape
# if self.fixed_dimension == 0:
# self.frame_shape = (height, self.frame.get_width())
# else:
# self.frame_shape = (self.frame.get_height(), width)
# self.resize_frame_shape(fixed_dimension=self.fixed_dimension)
def get_mobjects_indicating_movement(self):
"""
Returns all mobjets whose movement implies that the camera
should think of all other mobjects on the screen as moving
"""
return [self.frame]
# <--Camer3D
def capture_mobjects(self, mobjects, **kwargs):
if self.C3D:
self.reset_rotation_matrix()
Cam.capture_mobjects(self, mobjects, **kwargs)
else:
# self.reset_frame_center()
# self.realign_frame_shape()
Cam.capture_mobjects(self, mobjects, **kwargs)
def get_value_trackers(self):
return [
self.phi_tracker,
self.theta_tracker,
self.distance_tracker,
self.gamma_tracker,
]
def modified_rgbas(self, vmobject, rgbas):
if not self.should_apply_shading:
return rgbas
if vmobject.shade_in_3d and (vmobject.get_num_points() > 0):
light_source_point = self.light_source.points[0]
if len(rgbas) < 2:
shaded_rgbas = rgbas.repeat(2, axis=0)
else:
shaded_rgbas = np.array(rgbas[:2])
shaded_rgbas[0, :3] = get_shaded_rgb(
shaded_rgbas[0, :3],
get_3d_vmob_start_corner(vmobject),
get_3d_vmob_start_corner_unit_normal(vmobject),
light_source_point,
)
shaded_rgbas[1, :3] = get_shaded_rgb(
shaded_rgbas[1, :3],
get_3d_vmob_end_corner(vmobject),
get_3d_vmob_end_corner_unit_normal(vmobject),
light_source_point,
)
return shaded_rgbas
return rgbas
def get_stroke_rgbas(self, vmobject, background=False):
if self.C3D:
return self.modified_rgbas(vmobject,
vmobject.get_stroke_rgbas(background))
else:
return Cam.get_stroke_rgbas(self, vmobject, background=False)
def get_fill_rgbas(self, vmobject):
if self.C3D:
return self.modified_rgbas(vmobject, vmobject.get_fill_rgbas())
else:
return Cam.get_fill_rgbas(self, vmobject)
def get_mobjects_to_display(self, *args, **kwargs):
if self.C3D:
mobjects = Cam.get_mobjects_to_display(self, *args, **kwargs)
rot_matrix = self.get_rotation_matrix()
def z_key(mob):
if not (hasattr(mob, "shade_in_3d") and mob.shade_in_3d):
return np.inf
# Assign a number to a three dimensional mobjects
# based on how close it is to the camera
return np.dot(mob.get_z_index_reference_point(),
rot_matrix.T)[2]
return sorted(mobjects, key=z_key)
else:
return Cam.get_mobjects_to_display(self, *args, **kwargs)
def get_phi(self):
return self.phi_tracker.get_value()
def get_theta(self):
return self.theta_tracker.get_value()
def get_distance(self):
return self.distance_tracker.get_value()
def get_gamma(self):
return self.gamma_tracker.get_value()
def set_phi(self, value):
self.phi_tracker.set_value(value)
def set_theta(self, value):
self.theta_tracker.set_value(value)
def set_distance(self, value):
self.distance_tracker.set_value(value)
def set_gamma(self, value):
self.gamma_tracker.set_value(value)
def reset_rotation_matrix(self):
self.rotation_matrix = self.generate_rotation_matrix()
def get_rotation_matrix(self):
return self.rotation_matrix
def generate_rotation_matrix(self):
phi = self.get_phi()
theta = self.get_theta()
gamma = self.get_gamma()
matrices = [
rotation_about_z(-theta - 90 * DEGREES),
rotation_matrix(-phi, RIGHT),
rotation_about_z(gamma),
]
result = np.identity(3)
for matrix in matrices:
result = np.dot(matrix, result)
return result
def project_points(self, points):
frame_center = self.get_frame_center()
distance = self.get_distance()
rot_matrix = self.get_rotation_matrix()
points = points - frame_center
points = np.dot(points, rot_matrix.T)
zs = points[:, 2]
for i in 0, 1:
if self.exponential_projection:
# Proper projedtion would involve multiplying
# x and y by d / (d-z). But for points with high
# z value that causes weird artifacts, and applying
# the exponential helps smooth it out.
factor = np.exp(zs / distance)
lt0 = zs < 0
factor[lt0] = (distance / (distance - zs[lt0]))
else:
factor = (distance / (distance - zs))
factor[(distance - zs) < 0] = 10**6
# clip_in_place(factor, 0, 10**6)
points[:, i] *= factor
points = points + frame_center
return points
def project_point(self, point):
return self.project_points(point.reshape((1, 3)))[0, :]
def transform_points_pre_display(self, mobject, points):
if self.C3D:
points = super().transform_points_pre_display(mobject, points)
fixed_orientation = mobject in self.fixed_orientation_mobjects
fixed_in_frame = mobject in self.fixed_in_frame_mobjects
if fixed_in_frame:
return points
if fixed_orientation:
center_func = self.fixed_orientation_mobjects[mobject]
center = center_func()
new_center = self.project_point(center)
return points + (new_center - center)
else:
return self.project_points(points)
else:
return Cam.transform_points_pre_display(self, mobject, points)
def add_fixed_orientation_mobjects(self,
*mobjects,
use_static_center_func=False,
center_func=None):
# This prevents the computation of mobject.get_center
# every single time a projetion happens
def get_static_center_func(mobject):
point = mobject.get_center()
return (lambda: point)
for mobject in mobjects:
if center_func:
func = center_func
elif use_static_center_func:
func = get_static_center_func(mobject)
else:
func = mobject.get_center
for submob in mobject.get_family():
self.fixed_orientation_mobjects[submob] = func
def add_fixed_in_frame_mobjects(self, *mobjects):
for mobject in self.extract_mobject_family_members(mobjects):
self.fixed_in_frame_mobjects.add(mobject)
def remove_fixed_orientation_mobjects(self, *mobjects):
for mobject in self.extract_mobject_family_members(mobjects):
if mobject in self.fixed_orientation_mobjects:
try:
self.fixed_orientation_mobjects.remove(mobject)
except:
self.fixed_orientation_mobjects.pop(mobject)
def remove_fixed_in_frame_mobjects(self, *mobjects):
for mobject in self.extract_mobject_family_members(mobjects):
if mobject in self.fixed_in_frame_mobjects:
self.fixed_in_frame_mobjects.remove(mobject)
class ThreeDCamera(Camera):
CONFIG = {
"shading_factor": 0.2,
"distance": 20.0,
"default_distance": 5.0,
"phi": 0, # Angle off z axis
"theta": -90 * DEGREES, # Rotation about z axis
"gamma": 0, # Rotation about normal vector to camera
"light_source_start_point": 9 * DOWN + 7 * LEFT + 10 * OUT,
"frame_center": ORIGIN,
"should_apply_shading": True,
"exponential_projection": False,
"max_allowable_norm": 3 * FRAME_WIDTH,
}
def __init__(self, *args, **kwargs):
Camera.__init__(self, *args, **kwargs)
self.phi_tracker = ValueTracker(self.phi)
self.theta_tracker = ValueTracker(self.theta)
self.distance_tracker = ValueTracker(self.distance)
self.gamma_tracker = ValueTracker(self.gamma)
self.light_source = Point(self.light_source_start_point)
self.frame_center = Point(self.frame_center)
self.fixed_orientation_mobjects = dict()
self.fixed_in_frame_mobjects = set()
self.reset_rotation_matrix()
def capture_mobjects(self, mobjects, **kwargs):
self.reset_rotation_matrix()
Camera.capture_mobjects(self, mobjects, **kwargs)
def get_value_trackers(self):
return [
self.phi_tracker,
self.theta_tracker,
self.distance_tracker,
self.gamma_tracker,
]
def modified_rgbas(self, vmobject, rgbas):
if not self.should_apply_shading:
return rgbas
if vmobject.shade_in_3d and (vmobject.get_num_points() > 0):
light_source_point = self.light_source.points[0]
if len(rgbas) < 2:
shaded_rgbas = rgbas.repeat(2, axis=0)
else:
shaded_rgbas = np.array(rgbas[:2])
shaded_rgbas[0, :3] = get_shaded_rgb(
shaded_rgbas[0, :3],
get_3d_vmob_start_corner(vmobject),
get_3d_vmob_start_corner_unit_normal(vmobject),
light_source_point,
)
shaded_rgbas[1, :3] = get_shaded_rgb(
shaded_rgbas[1, :3],
get_3d_vmob_end_corner(vmobject),
get_3d_vmob_end_corner_unit_normal(vmobject),
light_source_point,
)
return shaded_rgbas
return rgbas
def get_stroke_rgbas(self, vmobject, background=False):
return self.modified_rgbas(
vmobject, vmobject.get_stroke_rgbas(background)
)
def get_fill_rgbas(self, vmobject):
return self.modified_rgbas(
vmobject, vmobject.get_fill_rgbas()
)
def get_mobjects_to_display(self, *args, **kwargs):
mobjects = Camera.get_mobjects_to_display(
self, *args, **kwargs
)
rot_matrix = self.get_rotation_matrix()
def z_key(mob):
if not (hasattr(mob, "shade_in_3d") and mob.shade_in_3d):
return np.inf
# Assign a number to a three dimensional mobjects
# based on how close it is to the camera
return np.dot(
mob.get_z_index_reference_point(),
rot_matrix.T
)[2]
return sorted(mobjects, key=z_key)
def get_phi(self):
return self.phi_tracker.get_value()
def get_theta(self):
return self.theta_tracker.get_value()
def get_distance(self):
return self.distance_tracker.get_value()
def get_gamma(self):
return self.gamma_tracker.get_value()
def get_frame_center(self):
return self.frame_center.points[0]
def set_phi(self, value):
self.phi_tracker.set_value(value)
def set_theta(self, value):
self.theta_tracker.set_value(value)
def set_distance(self, value):
self.distance_tracker.set_value(value)
def set_gamma(self, value):
self.gamma_tracker.set_value(value)
def set_frame_center(self, point):
self.frame_center.move_to(point)
def reset_rotation_matrix(self):
self.rotation_matrix = self.generate_rotation_matrix()
def get_rotation_matrix(self):
return self.rotation_matrix
def generate_rotation_matrix(self):
phi = self.get_phi()
theta = self.get_theta()
gamma = self.get_gamma()
matrices = [
rotation_about_z(-theta - 90 * DEGREES),
rotation_matrix(-phi, RIGHT),
rotation_about_z(gamma),
]
result = np.identity(3)
for matrix in matrices:
result = np.dot(matrix, result)
return result
def project_points(self, points):
frame_center = self.get_frame_center()
distance = self.get_distance()
rot_matrix = self.get_rotation_matrix()
points = points - frame_center
points = np.dot(points, rot_matrix.T)
zs = points[:, 2]
for i in 0, 1:
if self.exponential_projection:
# Proper projedtion would involve multiplying
# x and y by d / (d-z). But for points with high
# z value that causes weird artifacts, and applying
# the exponential helps smooth it out.
factor = np.exp(zs / distance)
lt0 = zs < 0
factor[lt0] = (distance / (distance - zs[lt0]))
else:
factor = (distance / (distance - zs))
factor[(distance - zs) < 0] = 10**6
# clip_in_place(factor, 0, 10**6)
points[:, i] *= factor
points = points + frame_center
return points
def project_point(self, point):
return self.project_points(point.reshape((1, 3)))[0, :]
def transform_points_pre_display(self, mobject, points):
points = super().transform_points_pre_display(mobject, points)
fixed_orientation = mobject in self.fixed_orientation_mobjects
fixed_in_frame = mobject in self.fixed_in_frame_mobjects
if fixed_in_frame:
return points
if fixed_orientation:
center_func = self.fixed_orientation_mobjects[mobject]
center = center_func()
new_center = self.project_point(center)
return points + (new_center - center)
else:
return self.project_points(points)
def add_fixed_orientation_mobjects(
self, *mobjects,
use_static_center_func=False,
center_func=None):
# This prevents the computation of mobject.get_center
# every single time a projetion happens
def get_static_center_func(mobject):
point = mobject.get_center()
return (lambda: point)
for mobject in mobjects:
if center_func:
func = center_func
elif use_static_center_func:
func = get_static_center_func(mobject)
else:
func = mobject.get_center
for submob in mobject.get_family():
self.fixed_orientation_mobjects[submob] = func
def add_fixed_in_frame_mobjects(self, *mobjects):
for mobject in self.extract_mobject_family_members(mobjects):
self.fixed_in_frame_mobjects.add(mobject)
def remove_fixed_orientation_mobjects(self, *mobjects):
for mobject in self.extract_mobject_family_members(mobjects):
if mobject in self.fixed_orientation_mobjects:
self.fixed_orientation_mobjects.remove(mobject)
def remove_fixed_in_frame_mobjects(self, *mobjects):
for mobject in self.extract_mobject_family_members(mobjects):
if mobject in self.fixed_in_frame_mobjects:
self.fixed_in_frame_mobjects.remove(mobject)