Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Final animations for the clacks solution

Grant Sanderson610103f92cb7
diff --git a/active_projects/clacks/all_s2_scenes.py b/active_projects/clacks/all_s2_scenes.py
index 64d949d86..3617f82a8 100644
--- a/active_projects/clacks/all_s2_scenes.py
+++ b/active_projects/clacks/all_s2_scenes.py
@@ -1,28 +1,62 @@
-# from active_projects.clacks import question
-# from active_projects.clacks import solution1
+from active_projects.clacks import question
from active_projects.clacks.solution2 import block_collision_scenes
-from active_projects.clacks.solution2 import simple_scenes
-from active_projects.clacks.solution2 import wordy_scenes
+from active_projects.clacks.solution2 import mirror_scenes
from active_projects.clacks.solution2 import pi_creature_scenes
from active_projects.clacks.solution2 import position_phase_space
+from active_projects.clacks.solution2 import simple_scenes
+from active_projects.clacks.solution2 import wordy_scenes
OUTPUT_DIRECTORY = "clacks_solution2"
ALL_SCENE_CLASSES = [
+ question.NameIntro,
block_collision_scenes.IntroducePreviousTwoVideos,
block_collision_scenes.PreviousTwoVideos,
+ simple_scenes.ComingUpWrapper,
wordy_scenes.ConnectionToOptics,
pi_creature_scenes.OnAnsweringTwice,
simple_scenes.LastVideoWrapper,
+ simple_scenes.Rectangle,
+ simple_scenes.ShowRectangleCreation,
+ simple_scenes.LeftEdge,
+ simple_scenes.RightEdge,
position_phase_space.IntroducePositionPhaseSpace,
position_phase_space.UnscaledPositionPhaseSpaceMass100,
+ simple_scenes.FourtyFiveDegreeLine,
position_phase_space.EqualMassCase,
pi_creature_scenes.AskAboutEqualMassMomentumTransfer,
position_phase_space.FailedAngleRelation,
position_phase_space.UnscaledPositionPhaseSpaceMass10,
pi_creature_scenes.ComplainAboutRelevanceOfAnalogy,
simple_scenes.LastVideoWrapper,
+ simple_scenes.NoteOnEnergyLostToSound,
position_phase_space.RescaleCoordinates,
wordy_scenes.ConnectionToOpticsTransparent,
position_phase_space.RescaleCoordinatesMass16,
position_phase_space.RescaleCoordinatesMass64,
+ position_phase_space.RescaleCoordinatesMass100,
+ position_phase_space.IntroduceVelocityVector,
+ position_phase_space.IntroduceVelocityVectorWithoutZoom,
+ position_phase_space.ShowMomentumConservation,
+ wordy_scenes.RearrangeMomentumEquation,
+ simple_scenes.DotProductVideoWrapper,
+ simple_scenes.ShowDotProductMeaning,
+ position_phase_space.JustTheProcessNew,
+ mirror_scenes.ShowTrajectoryWithChangingTheta,
+ pi_creature_scenes.ReplaceOneTrickySceneWithAnother,
+ mirror_scenes.MirrorAndWiresOverlay,
+ pi_creature_scenes.NowForTheGoodPart,
+ mirror_scenes.ReflectWorldThroughMirrorNew,
+ mirror_scenes.ReflectWorldThroughMirrorThetaPoint2,
+ mirror_scenes.ReflectWorldThroughMirrorThetaPoint1,
+ simple_scenes.AskAboutAddingThetaToItself,
+ simple_scenes.AskAboutAddingThetaToItselfThetaPoint1,
+ simple_scenes.AskAboutAddingThetaToItselfThetaPoint2,
+ simple_scenes.FinalFormula,
+ simple_scenes.ArctanSqrtPoint1Angle,
+ simple_scenes.ReviewWrapper,
+ simple_scenes.SurprisedRandy,
+ simple_scenes.TwoSolutionsWrapper,
+ simple_scenes.FinalQuote,
+ simple_scenes.EndScreen,
+ simple_scenes.ClacksSolution2Thumbnail,
]
diff --git a/active_projects/clacks/question.py b/active_projects/clacks/question.py
index ca8642a21..f9b8ca98b 100644
--- a/active_projects/clacks/question.py
+++ b/active_projects/clacks/question.py
@@ -13,7 +13,7 @@ class Block(Square):
"stroke_color": WHITE,
"fill_color": None,
"sheen_direction": UL,
- "sheen": 0.5,
+ "sheen_factor": 0.5,
"sheen_direction": UL,
}
@@ -43,7 +43,7 @@ class Block(Square):
def mass_to_color(self, mass):
colors = [
LIGHT_GREY,
- BLUE_B,
+ BLUE_D,
BLUE_D,
BLUE_E,
BLUE_E,
@@ -225,7 +225,7 @@ class ClackFlashes(ContinualAnimation):
ContinualAnimation.__init__(self, group, **kwargs)
def update_mobject(self, dt):
- total_time = self.external_time
+ total_time = self.get_time()
group = self.mobject
for flash in self.flashes:
if flash.start_time < total_time < flash.end_time:
@@ -238,6 +238,9 @@ class ClackFlashes(ContinualAnimation):
if flash.mobject in group:
group.remove(flash.mobject)
+ def get_time(self):
+ return self.external_time
+
class Wall(Line):
CONFIG = {
@@ -410,6 +413,10 @@ class NameIntro(Scene):
rate_func=None,
)
)
+ self.play(
+ Flash(brown.get_right(), run_time=flash_time),
+ Restore(brown, rate_func=None)
+ )
class MathAndPhysicsConspiring(Scene):
@@ -1558,16 +1565,16 @@ class Thumbnail(BlocksAndWallExample, MovingCameraScene):
BlocksAndWallExample.setup(self)
def construct(self):
- # self.camera_frame.shift(0.9 * UP)
- self.mobjects.insert(
- 0,
- FullScreenFadeRectangle(
- color=DARK_GREY,
- opacity=0.5,
- sheen_direction=UL,
- sheen=0.5,
- ),
- )
+ self.camera_frame.shift(0.9 * UP)
+ # self.mobjects.insert(
+ # 0,
+ # FullScreenFadeRectangle(
+ # color=DARK_GREY,
+ # opacity=0.5,
+ # sheen_direction=UL,
+ # sheen=0.5,
+ # ),
+ # )
self.thicken_lines()
self.grow_labels()
self.add_vector()
@@ -1587,7 +1594,7 @@ class Thumbnail(BlocksAndWallExample, MovingCameraScene):
def add_vector(self):
blocks = self.blocks
- arrow = Vector(
+ arrow = self.arrow = Vector(
2.5 * LEFT,
color=RED,
rectangular_stem_width=1.5,
@@ -1600,7 +1607,9 @@ class Thumbnail(BlocksAndWallExample, MovingCameraScene):
self.add(arrow)
def add_text(self):
- question = TextMobject("How many\\\\collisions?")
+ question = self.question = TextMobject(
+ "How many\\\\collisions?"
+ )
question.scale(2.5)
question.to_edge(UP)
question.set_color(YELLOW)
diff --git a/active_projects/clacks/solution2/block_collision_scenes.py b/active_projects/clacks/solution2/block_collision_scenes.py
index b300087f7..17b83fc7e 100644
--- a/active_projects/clacks/solution2/block_collision_scenes.py
+++ b/active_projects/clacks/solution2/block_collision_scenes.py
@@ -7,7 +7,7 @@ class PreviousTwoVideos(BlocksAndWallExample):
"sliding_blocks_config": {
"block1_config": {
"mass": 1e2,
- "velocity": -1,
+ "velocity": -2,
"width": 4,
"distance": 8,
},
diff --git a/active_projects/clacks/solution2/mirror_scenes.py b/active_projects/clacks/solution2/mirror_scenes.py
new file mode 100644
index 000000000..7999e65ad
--- /dev/null
+++ b/active_projects/clacks/solution2/mirror_scenes.py
@@ -0,0 +1,1021 @@
+from big_ol_pile_of_manim_imports import *
+
+
+class MirrorScene(Scene):
+ CONFIG = {
+ "center": DOWN + 3 * LEFT,
+ "line_length": FRAME_WIDTH,
+ "start_theta": np.arctan(0.25),
+ "start_y_offset": 0.5,
+ "start_x_offset": 8,
+ "arc_config": {
+ "radius": 1,
+ "stroke_color": WHITE,
+ "stroke_width": 2,
+ },
+ "trajectory_point_spacing": 0.1,
+ "trajectory_style": {
+ "stroke_color": YELLOW,
+ "stroke_width": 2,
+ },
+ "ghost_lines_style": {
+ "stroke_color": WHITE,
+ "stroke_width": 1,
+ "stroke_opacity": 0.5,
+ },
+ # "reflect_sound": "ping",
+ "reflect_sound": "pen_click",
+ }
+
+ def setup(self):
+ self.theta_tracker = ValueTracker(self.start_theta)
+ self.start_y_offset_tracker = ValueTracker(self.start_y_offset)
+ self.start_x_offset_tracker = ValueTracker(self.start_x_offset)
+ self.center_tracker = VectorizedPoint(self.center)
+ self.beam_point = VectorizedPoint(np.array([
+ self.get_start_x_offset(),
+ self.get_start_y_offset(),
+ 0
+ ]))
+ self.ghost_beam_point = self.beam_point.copy()
+ self.is_sound_allowed = False
+
+ self.mirrors = self.get_mirrors()
+ self.arc = self.get_arc()
+ self.theta_symbol = self.get_theta_symbol()
+ self.trajectory = self.get_trajectory()
+ self.ghost_trajectory = self.get_ghost_trajectory()
+ self.theta_display = self.get_theta_display()
+ self.count_display_word = self.get_count_display_word()
+ self.count_display_number = self.get_count_display_number()
+ self.last_count = self.get_count()
+
+ # Add some of them
+ self.add(
+ self.mirrors,
+ self.arc,
+ self.theta_symbol,
+ self.theta_display,
+ self.count_display_word,
+ self.count_display_number,
+ )
+
+ def get_center(self):
+ return self.center_tracker.get_location()
+
+ def get_theta(self):
+ return self.theta_tracker.get_value()
+
+ def get_start_y_offset(self):
+ return self.start_y_offset_tracker.get_value()
+
+ def get_start_x_offset(self):
+ return self.start_x_offset_tracker.get_value()
+
+ def get_mirror(self):
+ mirror = VGroup(
+ Line(ORIGIN, 2 * RIGHT),
+ Line(ORIGIN, 2 * RIGHT),
+ Line(ORIGIN, (self.line_length - 4) * RIGHT),
+ )
+ mirror.arrange_submobjects(RIGHT, buff=0)
+ mirror.set_stroke(width=5)
+ mirror[0::2].set_stroke((WHITE, GREY))
+ mirror[1::2].set_stroke((GREY, WHITE))
+ return mirror
+
+ def get_mirrors(self):
+ mirrors = VGroup(self.get_mirror(), self.get_mirror())
+
+ def update_mirrors(mirrors):
+ m1, m2 = mirrors
+ center = self.get_center()
+ theta = self.get_theta()
+ m1.move_to(center, DL)
+ m2.become(m1)
+ m2.rotate(theta, about_point=center)
+
+ mirrors.add_updater(update_mirrors)
+ return mirrors
+
+ def get_arc(self, radius=0.5):
+ return updating_mobject_from_func(lambda: Arc(
+ start_angle=0,
+ angle=self.get_theta(),
+ arc_center=self.get_center(),
+ **self.arc_config,
+ ))
+
+ def get_theta_symbol(self, arc=None, buff=0.15):
+ if arc is None:
+ arc = self.arc
+ symbol = TexMobject("\\theta")
+
+ def update_symbol(symbol):
+ midpoint = arc.point_from_proportion(0.5)
+ center = arc.arc_center
+ vect = (midpoint - center)
+ max_height = 0.8 * arc.get_height()
+ if symbol.get_height() > max_height:
+ symbol.set_height(max_height)
+ symbol.move_to(
+ center + vect + buff * normalize(vect)
+ )
+ symbol.add_updater(update_symbol)
+ return symbol
+
+ def get_ghost_collision_points(self):
+ x = self.get_start_x_offset()
+ y = self.get_start_y_offset()
+ theta = self.get_theta()
+
+ points = [np.array([x, y, 0])]
+ points += [
+ np.array([x, y, 0])
+ for k in range(1, int(PI / theta) + 1)
+ for x in [y / np.tan(k * theta)]
+ if abs(x) < FRAME_WIDTH
+ ]
+ points.append(points[-1] + x * LEFT)
+ points = np.array(points)
+ points += self.get_center()
+ return points
+
+ def get_collision_points(self, ghost_points=None):
+ if ghost_points is None:
+ ghost_points = self.get_ghost_collision_points()
+ theta = self.get_theta()
+ center = self.get_center()
+ points = []
+ for ghost_point in ghost_points:
+ vect = ghost_point - center
+ angle = angle_of_vector(vect)
+ k = int(angle / theta)
+ if k % 2 == 0:
+ vect = rotate_vector(vect, -k * theta)
+ else:
+ vect = rotate_vector(vect, -(k + 1) * theta)
+ vect[1] = abs(vect[1])
+ points.append(center + vect)
+ return points
+
+ def get_trajectory(self, collision_points=None):
+ if collision_points is None:
+ collision_points = self.get_collision_points()
+ points = []
+ spacing = self.trajectory_point_spacing
+ for p0, p1 in zip(collision_points, collision_points[1:]):
+ n_intervals = max(1, int(get_norm(p1 - p0) / spacing))
+ for alpha in np.linspace(0, 1, n_intervals + 1):
+ points.append(interpolate(p0, p1, alpha))
+ trajectory = VMobject()
+ trajectory.set_points_as_corners(points)
+ trajectory.set_style(**self.trajectory_style)
+ return trajectory
+
+ def get_ghost_trajectory(self):
+ return self.get_trajectory(self.get_ghost_collision_points())
+
+ def get_collision_point_counts(self, collision_points=None):
+ if collision_points is None:
+ collision_points = self.get_collision_points()[1:-1]
+ result = VGroup()
+ for n, point in enumerate(collision_points):
+ count = Integer(n + 1)
+ count.set_height(0.25)
+ vect = UP if n % 2 == 0 else DOWN
+ count.next_to(point, vect, SMALL_BUFF)
+ result.add(count)
+ return result
+
+ def get_collision_count_anim(self, collision_point_counts=None):
+ if collision_point_counts is None:
+ collision_point_counts = self.get_collision_point_counts()
+ group = VGroup()
+
+ def update(group):
+ count = self.get_count()
+ if count == 0:
+ group.submobjects = []
+ elif count < len(collision_point_counts) + 1:
+ group.submobjects = [
+ collision_point_counts[count - 1]
+ ]
+
+ return UpdateFromFunc(group, update, remover=True)
+
+ def get_ghost_lines(self):
+ line = self.mirrors[0]
+ center = self.get_center()
+ theta = self.get_theta()
+ lines = VGroup()
+ for k in range(1, int(PI / theta) + 2):
+ new_line = line.copy()
+ new_line.rotate(k * theta, about_point=center)
+ lines.add(new_line)
+ lines.set_style(**self.ghost_lines_style)
+ return lines
+
+ # Displays
+ def get_theta_display(self):
+ lhs = TexMobject("\\theta = ")
+ radians = DecimalNumber()
+ radians.add_updater(
+ lambda m: m.set_value(self.get_theta())
+ )
+ radians_word = TextMobject("radians")
+ radians_word.next_to(
+ radians, RIGHT, aligned_edge=DOWN
+ )
+ equals = TexMobject("=")
+ degrees = Integer(0, unit="^\\circ")
+ degrees.add_updater(
+ lambda m: m.set_value(
+ int(np.round(self.get_theta() / DEGREES))
+ )
+ )
+ group = VGroup(lhs, radians, radians_word, equals, degrees)
+ group.arrange_submobjects(RIGHT, aligned_edge=DOWN)
+ equals.align_to(lhs[-1], DOWN)
+ group.to_corner(UL)
+ return group
+
+ def get_count_display_word(self):
+ result = TextMobject("\\# Bounces: ")
+ result.to_corner(UL)
+ result.shift(DOWN)
+ result.set_color(YELLOW)
+ return result
+
+ def get_count_display_number(self, count_display_word=None, ghost_beam_point=None):
+ if count_display_word is None:
+ count_display_word = self.count_display_word
+ result = Integer()
+ result.next_to(
+ count_display_word[-1], RIGHT,
+ aligned_edge=DOWN,
+ )
+ result.set_color(YELLOW)
+ result.add_updater(
+ lambda m: m.set_value(self.get_count())
+ )
+ return result
+
+ def get_count(self, ghost_beam_point=None):
+ if ghost_beam_point is None:
+ ghost_beam_point = self.ghost_beam_point.get_location()
+ angle = angle_of_vector(
+ ghost_beam_point - self.get_center()
+ )
+ return int(angle / self.get_theta())
+
+ # Sounds
+ def allow_sound(self):
+ self.is_sound_allowed = True
+
+ def disallow_sound(self):
+ self.is_sound_allowed = False
+
+ def continual_update(self, dt):
+ super().continual_update(dt)
+ if self.get_count() != self.last_count:
+ self.last_count = self.get_count()
+ if self.is_sound_allowed:
+ self.add_sound(
+ self.reflect_sound,
+ gain=-20,
+ )
+
+ # Bouncing animations
+ def show_bouncing(self, run_time=5):
+ trajectory = self.trajectory
+ ghost_trajectory = self.get_ghost_trajectory()
+
+ beam_anims = self.get_shooting_beam_anims(
+ trajectory, ghost_trajectory
+ )
+ count_anim = self.get_collision_count_anim()
+
+ self.allow_sound()
+ self.play(count_anim, *beam_anims, run_time=run_time)
+ self.disallow_sound()
+
+ def get_special_flash(self, mobject, stroke_width, time_width, rate_func=None, **kwargs):
+ kwargs["rate_func"] = rate_func
+ mob_copy = mobject.copy()
+ mob_copy.set_stroke(width=stroke_width)
+ mob_copy.time_width = time_width
+ return UpdateFromAlphaFunc(
+ mob_copy,
+ lambda m, a: m.pointwise_become_partial(
+ mobject,
+ max(a - (1 - a) * m.time_width, 0),
+ a,
+ ),
+ **kwargs
+ )
+
+ def get_shooting_beam_anims(self,
+ trajectory,
+ ghost_trajectory=None,
+ update_beam_point=True,
+ num_flashes=20,
+ min_time_width=0.01,
+ max_time_width=0.5,
+ min_stroke_width=0.01,
+ max_stroke_width=6,
+ fade_trajectory=True,
+ faded_trajectory_width=0.25,
+ faded_trajectory_time_exp=0.2,
+ ):
+ # Most flashes
+ result = [
+ self.get_special_flash(trajectory, stroke_width, time_width)
+ for stroke_width, time_width in zip(
+ np.linspace(max_stroke_width, min_stroke_width, num_flashes),
+ np.linspace(min_time_width, max_time_width, num_flashes),
+ )
+ ]
+
+ # Make sure beam point is updated
+ if update_beam_point:
+ smallest_flash = result[0]
+ result.append(
+ UpdateFromFunc(
+ self.beam_point,
+ lambda m: m.move_to(smallest_flash.mobject.points[-1])
+ )
+ )
+
+ # Make sure ghost beam point is updated
+ if ghost_trajectory:
+ ghost_flash = self.get_special_flash(
+ ghost_trajectory, 0, min_time_width,
+ )
+ ghost_beam_point_update = UpdateFromFunc(
+ self.ghost_beam_point,
+ lambda m: m.move_to(ghost_flash.mobject.points[-1])
+ )
+ result += [
+ ghost_flash,
+ ghost_beam_point_update,
+ ]
+
+ # Fade trajectory
+ if fade_trajectory:
+ ftte = faded_trajectory_time_exp
+ result.append(
+ ApplyMethod(
+ trajectory.set_stroke,
+ {"width": faded_trajectory_width},
+ rate_func=lambda t: there_and_back(t)**ftte
+ ),
+ )
+ return result
+
+
+class ShowTrajectoryWithChangingTheta(MirrorScene):
+ def construct(self):
+ trajectory = self.trajectory
+ self.add(trajectory)
+ angles = [30 * DEGREES, 10 * DEGREES]
+ ys = [1, 1]
+ self.show_bouncing()
+ for angle, y in zip(angles, ys):
+ rect = SurroundingRectangle(self.theta_display)
+ self.play(
+ self.theta_tracker.set_value, angle,
+ self.start_y_offset_tracker.set_value, y,
+ FadeIn(rect, rate_func=there_and_back, remover=True),
+ UpdateFromFunc(
+ trajectory,
+ lambda m: m.become(self.get_trajectory())
+ ),
+ run_time=2
+ )
+ self.show_bouncing()
+ self.wait(2)
+
+
+class ReflectWorldThroughMirrorNew(MirrorScene):
+ CONFIG = {
+ "start_y_offset": 1.25,
+ "center": DOWN,
+ "randy_height": 1,
+ "partial_trajectory_values": [
+ 0, 0.22, 0.28, 0.315, 1,
+ ],
+ }
+
+ def construct(self):
+ self.add_randy()
+ self.shift_displays()
+ self.add_ghost_beam_point()
+ self.up_through_first_bounce()
+ self.create_reflected_worlds()
+ self.create_reflected_trajectories()
+ self.first_reflection()
+ self.next_reflection(2)
+ self.next_reflection(3)
+ self.unfold_all_reflected_worlds()
+ self.show_completed_beam()
+ self.blink_all_randys()
+ self.add_randy_updates()
+ self.show_all_trajectories()
+ self.focus_on_two_important_trajectories()
+
+ def add_randy(self):
+ randy = self.randy = Randolph()
+ randy.flip()
+ randy.set_height(self.randy_height)
+ randy.change("pondering")
+ randy.align_to(self.mirrors, DOWN)
+ randy.shift(0.01 * UP)
+ randy.to_edge(RIGHT, buff=1)
+ randy.tracked_mobject = self.trajectory
+ randy.add_updater(
+ lambda m: m.look_at(
+ m.tracked_mobject.points[-1]
+ )
+ )
+ self.add(randy)
+
+ def shift_displays(self):
+ VGroup(
+ self.theta_display,
+ self.count_display_word,
+ self.count_display_number,
+ ).to_edge(DOWN)
+
+ def add_ghost_beam_point(self):
+ self.ghost_beam_point.add_updater(
+ lambda m: m.move_to(
+ self.ghost_trajectory.points[-1]
+ )
+ )
+ self.add(self.ghost_beam_point)
+
+ def up_through_first_bounce(self):
+ self.play(*self.get_both_partial_trajectory_anims(
+ *self.partial_trajectory_values[:2]
+ ))
+ self.wait()
+
+ def create_reflected_worlds(self):
+ mirrors = self.mirrors
+ triangle = Polygon(*[
+ mirrors.get_corner(corner)
+ for corner in (DR, DL, UR)
+ ])
+ triangle.set_stroke(width=0)
+ triangle.set_fill(BLUE_E, opacity=0)
+ world = self.world = VGroup(
+ triangle,
+ mirrors,
+ self.arc,
+ self.theta_symbol,
+ self.randy,
+ )
+ reflected_worlds = self.get_reflected_worlds(world)
+ self.reflected_worlds = reflected_worlds
+ # Alternating triangle opacities
+ for rw in reflected_worlds[::2]:
+ rw[0].set_fill(opacity=0.25)
+
+ def create_reflected_trajectories(self):
+ self.reflected_trajectories = updating_mobject_from_func(
+ lambda: self.get_reflected_worlds(self.trajectory)
+ )
+
+ def first_reflection(self):
+ reflected_trajectory = self.reflected_trajectories[0]
+ reflected_world = self.reflected_worlds[0]
+ world = self.world
+ trajectory = self.trajectory
+ ghost_trajectory = self.ghost_trajectory
+
+ self.play(
+ TransformFromCopy(world, reflected_world),
+ TransformFromCopy(trajectory, reflected_trajectory),
+ run_time=2
+ )
+ beam_anims = self.get_shooting_beam_anims(
+ ghost_trajectory,
+ fade_trajectory=False,
+ )
+ self.play(
+ *[
+ ApplyMethod(m.set_stroke, GREY, 1)
+ for m in (trajectory, reflected_trajectory)
+ ] + beam_anims,
+ run_time=2
+ )
+ for x in range(2):
+ self.play(*beam_anims, run_time=2)
+
+ ghost_trajectory.set_stroke(YELLOW, 4)
+ self.bring_to_front(ghost_trajectory)
+ self.play(FadeIn(ghost_trajectory))
+ self.wait()
+
+ def next_reflection(self, index=2):
+ i = index
+ self.play(
+ *self.get_both_partial_trajectory_anims(
+ *self.partial_trajectory_values[i - 1:i + 1]
+ ),
+ UpdateFromFunc(
+ VMobject(), # Null
+ lambda m: self.reflected_trajectories.update(),
+ remover=True,
+ ),
+ )
+
+ anims = [
+ TransformFromCopy(*reflections[i - 2:i])
+ for reflections in [
+ self.reflected_worlds,
+ self.reflected_trajectories
+ ]
+ ]
+ self.play(*anims, run_time=2)
+ self.add(self.ghost_trajectory)
+ self.wait()
+
+ def unfold_all_reflected_worlds(self):
+ worlds = self.reflected_worlds
+ trajectories = self.reflected_trajectories
+
+ pairs = [
+ (VGroup(w1, t1), VGroup(w2, t2))
+ for w1, w2, t1, t2 in zip(
+ worlds[2:], worlds[3:],
+ trajectories[2:], trajectories[3:],
+ )
+ ]
+
+ new_worlds = VGroup() # Brought to you by Dvorak
+ for m1, m2 in pairs:
+ m2.pre_world = m1.copy()
+ new_worlds.add(m2)
+ for mob in new_worlds:
+ mob.save_state()
+ mob.become(mob.pre_world)
+ mob.fade(1)
+
+ self.play(LaggedStart(
+ Restore, new_worlds,
+ lag_ratio=0.4,
+ run_time=3
+ ))
+
+ def show_completed_beam(self):
+ self.add(self.reflected_trajectories)
+ self.add(self.ghost_trajectory)
+ self.play(*self.get_both_partial_trajectory_anims(
+ *self.partial_trajectory_values[-2:],
+ run_time=7
+ ))
+
+ def blink_all_randys(self):
+ randys = self.randys = VGroup(self.randy)
+ randys.add(*[rw[-1] for rw in self.reflected_worlds])
+ self.play(LaggedStart(Blink, randys))
+
+ def add_randy_updates(self):
+ # Makes it run slower, but it's fun!
+ reflected_randys = VGroup(*[
+ rw[-1] for rw in self.reflected_worlds
+ ])
+ reflected_randys.add_updater(
+ lambda m: m.become(
+ self.get_reflected_worlds(self.randy)
+ )
+ )
+ self.add(reflected_randys)
+
+ def show_all_trajectories(self):
+ ghost_trajectory = self.ghost_trajectory
+ reflected_trajectories = self.reflected_trajectories
+ trajectory = self.trajectory
+ reflected_trajectories.suspend_updating()
+ trajectories = VGroup(trajectory, *reflected_trajectories)
+
+ all_mirrors = VGroup(*[
+ world[1]
+ for world in it.chain([self.world], self.reflected_worlds)
+ ])
+
+ self.play(
+ FadeOut(ghost_trajectory),
+ trajectories.set_stroke, YELLOW, 0.5,
+ all_mirrors.set_stroke, {"width": 1},
+ )
+
+ # All trajectory light beams
+ flash_groups = [
+ self.get_shooting_beam_anims(
+ mob, fade_trajectory=False,
+ )
+ for mob in trajectories
+ ]
+ all_flashes = list(it.chain(*flash_groups))
+
+ # Have all the pi creature eyes follows
+ self.randy.tracked_mobject = all_flashes[0].mobject
+
+ # Highlight the illustory straight beam
+ red_ghost = self.ghost_trajectory.copy()
+ red_ghost.set_color(RED)
+ red_ghost_beam = self.get_shooting_beam_anims(
+ red_ghost, fade_trajectory=False,
+ )
+
+ num_repeats = 3
+ for x in range(num_repeats):
+ anims = list(all_flashes)
+ if x == num_repeats - 1:
+ anims += list(red_ghost_beam)
+ self.randy.tracked_mobject = red_ghost_beam[0].mobject
+ for flash in all_flashes:
+ if hasattr(flash.mobject, "time_width"):
+ flash.mobject.set_stroke(
+ width=0.25 * flash.mobject.get_stroke_width()
+ )
+ flash.mobject.time_width *= 0.25
+ self.play(*anims, run_time=3)
+
+ def focus_on_two_important_trajectories(self):
+ self.ghost_trajectory.set_stroke(YELLOW, 1)
+ self.play(
+ FadeOut(self.reflected_trajectories),
+ FadeIn(self.ghost_trajectory),
+ self.trajectory.set_stroke, YELLOW, 1,
+ )
+ self.add_flashing_windows()
+ t_beam_anims = self.get_shooting_beam_anims(self.trajectory)
+ gt_beam_anims = self.get_shooting_beam_anims(self.ghost_trajectory)
+ self.ghost_beam_point.clear_updaters()
+ self.ghost_beam_point.add_updater(
+ lambda m: m.move_to(
+ gt_beam_anims[0].mobject.points[-1]
+ )
+ )
+ self.randy.tracked_mobject = t_beam_anims[0].mobject
+ self.allow_sound()
+ self.play(
+ *t_beam_anims, *gt_beam_anims,
+ run_time=6
+ )
+ self.add_room_color_updates()
+ self.play(
+ *t_beam_anims, *gt_beam_anims,
+ run_time=6
+ )
+ self.blink_all_randys()
+ self.play(
+ *t_beam_anims, *gt_beam_anims,
+ run_time=6
+ )
+
+ # Helpers
+ def get_reflected_worlds(self, world, n_reflections=None):
+ theta = self.get_theta()
+ center = self.get_center()
+ if n_reflections is None:
+ n_reflections = int(PI / theta)
+
+ result = VGroup()
+ last_world = world
+ for n in range(n_reflections):
+ vect = rotate_vector(RIGHT, (n + 1) * theta)
+ reflected_world = last_world.copy()
+ reflected_world.clear_updaters()
+ reflected_world.rotate(
+ PI, axis=vect, about_point=center,
+ )
+ last_world = reflected_world
+ result.add(last_world)
+ return result
+
+ def get_partial_trajectory_anims(self, trajectory, a, b, **kwargs):
+ if not hasattr(trajectory, "full_self"):
+ trajectory.full_self = trajectory.copy()
+ return UpdateFromAlphaFunc(
+ trajectory,
+ lambda m, alpha: m.pointwise_become_partial(
+ m.full_self, 0,
+ interpolate(a, b, alpha)
+ ),
+ **kwargs
+ )
+
+ def get_both_partial_trajectory_anims(self, a, b, run_time=2, **kwargs):
+ kwargs["run_time"] = run_time
+ return [
+ self.get_partial_trajectory_anims(
+ mob, a, b, **kwargs
+ )
+ for mob in (self.trajectory, self.ghost_trajectory)
+ ]
+
+ def add_flashing_windows(self):
+ theta = self.get_theta()
+ center = self.get_center()
+ windows = self.windows = VGroup(*[
+ Line(
+ center,
+ center + rotate_vector(10 * RIGHT, k * theta),
+ color=BLUE,
+ stroke_width=0,
+ )
+ for k in range(0, self.get_count() + 1)
+ ])
+ windows[0].set_stroke(opacity=0)
+
+ # Warning, windows update manager may launch
+ def update_windows(windows):
+ windows.set_stroke(width=0)
+ windows[self.get_count()].set_stroke(width=5)
+ windows.add_updater(update_windows)
+ self.add(windows)
+
+ def add_room_color_updates(self):
+ def update_reflected_worlds(worlds):
+ for n, world in enumerate(worlds):
+ worlds[n][0].set_fill(
+ opacity=(0.25 if (n % 2 == 0) else 0)
+ )
+ index = self.get_count() - 1
+ if index < 0:
+ return
+ worlds[index][0].set_fill(opacity=0.5)
+ self.reflected_worlds.add_updater(update_reflected_worlds)
+ self.add(self.reflected_worlds)
+
+
+class ReflectWorldThroughMirrorThetaPoint2(ReflectWorldThroughMirrorNew):
+ CONFIG = {
+ "start_theta": 0.2,
+ "randy_height": 0.8,
+ }
+
+
+class ReflectWorldThroughMirrorThetaPoint1(ReflectWorldThroughMirrorNew):
+ CONFIG = {
+ "start_theta": 0.1,
+ "randy_height": 0.5,
+ "start_y_offset": 0.5,
+ "arc_config": {
+ "radius": 0.5,
+ },
+ }
+
+
+class MirrorAndWiresOverlay(MirrorScene):
+ CONFIG = {
+ "wire_pixel_points": [
+ (355, 574),
+ (846, 438),
+ (839, 629),
+ (845, 288),
+ (1273, 314),
+ ],
+ "max_x_pixel": 1440,
+ "max_y_pixel": 1440,
+ }
+
+ def setup(self):
+ self.last_count = 0
+
+ def get_count(self):
+ return 0
+
+ def get_shooting_beam_anims(self, mobject, **new_kwargs):
+ kwargs = {
+ "update_beam_point": False,
+ "fade_trajectory": False,
+ "max_stroke_width": 10,
+ }
+ kwargs.update(new_kwargs)
+ return super().get_shooting_beam_anims(mobject, **kwargs)
+
+ def construct(self):
+ self.add_wires()
+ self.add_diagram()
+
+ self.introduce_wires()
+ self.show_illusion()
+ self.show_angles()
+
+ # self.show_reflecting_beam()
+
+ def add_wires(self):
+ ul_corner = TOP + LEFT_SIDE
+ points = self.wire_points = [
+ ul_corner + np.array([
+ (x / self.max_x_pixel) * FRAME_HEIGHT,
+ (-y / self.max_y_pixel) * FRAME_HEIGHT,
+ 0
+ ])
+ for x, y in self.wire_pixel_points
+ ]
+ wires = self.wires = VGroup(
+ Line(points[0], points[1]),
+ Line(points[1], points[2]),
+ Line(points[1], points[3]),
+ Line(points[1], points[4]),
+ )
+ wires.set_stroke(RED, 4)
+ self.dl_wire, self.dr_wire, self.ul_wire, self.ur_wire = wires
+
+ self.trajectory = VMobject()
+ self.trajectory.set_points_as_corners(points[:3])
+ self.ghost_trajectory = VMobject()
+ self.ghost_trajectory.set_points_as_corners([*points[:2], points[4]])
+ VGroup(self.trajectory, self.ghost_trajectory).match_style(
+ self.wires
+ )
+
+ def add_diagram(self):
+ diagram = self.diagram = VGroup()
+ rect = diagram.rect = Rectangle(
+ height=4, width=5,
+ stroke_color=WHITE,
+ stroke_width=1,
+ fill_color=BLACK,
+ fill_opacity=0.9,
+ )
+ rect.to_corner(UR)
+ diagram.add(rect)
+
+ center = rect.get_center()
+
+ mirror = diagram.mirror = VGroup(
+ Line(rect.get_left(), center + 1.5 * LEFT),
+ Line(center + 1.5 * LEFT, rect.get_right()),
+ )
+ mirror.scale(0.8)
+ mirror[0].set_color((WHITE, GREY))
+ mirror[1].set_color((GREY, WHITE))
+ diagram.add(mirror)
+
+ def set_as_reflection(m1, m2):
+ m1.become(m2)
+ m1.rotate(PI, axis=UP, about_point=center)
+
+ def set_as_mirror_image(m1, m2):
+ m1.become(m2)
+ m1.rotate(PI, axis=RIGHT, about_point=center)
+
+ wires = VGroup(*[
+ Line(center + np.array([-1, -1.5, 0]), center)
+ for x in range(4)
+ ])
+ dl_wire, dr_wire, ul_wire, ur_wire = wires
+ dr_wire.add_updater(
+ lambda m: set_as_reflection(m, dl_wire)
+ )
+ ul_wire.add_updater(
+ lambda m: set_as_mirror_image(m, dl_wire)
+ )
+ ur_wire.add_updater(
+ lambda m: set_as_mirror_image(m, dr_wire)
+ )
+
+ diagram.wires = wires
+ diagram.wires.set_stroke(RED, 2)
+ diagram.add(diagram.wires)
+
+ def introduce_wires(self):
+ dl_wire = self.dl_wire
+ dr_wire = self.dr_wire
+
+ def get_rect(wire):
+ rect = Rectangle(
+ width=wire.get_length(),
+ height=0.25,
+ color=YELLOW,
+ )
+ rect.rotate(wire.get_angle())
+ rect.move_to(wire)
+ return rect
+
+ for wire in dl_wire, dr_wire:
+ self.play(ShowCreationThenFadeOut(get_rect(wire)))
+ self.play(*self.get_shooting_beam_anims(wire))
+ self.wait()
+
+ diagram = self.diagram.copy()
+ diagram.clear_updaters()
+ self.play(
+ FadeIn(diagram.rect),
+ ShowCreation(diagram.mirror),
+ LaggedStart(ShowCreation, diagram.wires),
+ run_time=1
+ )
+ self.remove(diagram)
+ self.add(self.diagram)
+
+ self.wait()
+
+ def show_illusion(self):
+ g_trajectory = self.ghost_trajectory
+ d_trajectory = self.d_trajectory = Line(
+ self.diagram.wires[0].get_start(),
+ self.diagram.wires[3].get_start(),
+ )
+ d_trajectory.match_style(g_trajectory)
+
+ g_trajectory.points[0] += 0.2 * RIGHT + 0.1 * DOWN
+ g_trajectory.make_jagged()
+ for x in range(3):
+ self.play(
+ *self.get_shooting_beam_anims(g_trajectory),
+ *self.get_shooting_beam_anims(d_trajectory),
+ )
+ self.wait()
+
+ def show_angles(self):
+ dl_wire = self.diagram.wires[0]
+ dr_wire = self.diagram.wires[1]
+ center = self.diagram.get_center()
+ arc_config = {
+ "radius": 0.5,
+ "arc_center": center,
+ }
+
+ def get_dl_arc():
+ return Arc(
+ start_angle=PI,
+ angle=dl_wire.get_angle(),
+ **arc_config,
+ )
+ dl_arc = updating_mobject_from_func(get_dl_arc)
+
+ def get_dr_arc():
+ return Arc(
+ start_angle=0,
+ angle=dr_wire.get_angle() - PI,
+ **arc_config,
+ )
+ dr_arc = updating_mobject_from_func(get_dr_arc)
+
+ incidence = TextMobject("Incidence")
+ reflection = TextMobject("Reflection")
+ words = VGroup(incidence, reflection)
+ words.scale(0.75)
+ incidence.add_updater(
+ lambda m: m.next_to(dl_arc, LEFT, SMALL_BUFF)
+ )
+ reflection.add_updater(
+ lambda m: m.next_to(dr_arc, RIGHT, SMALL_BUFF)
+ )
+ for word in words:
+ word.set_background_stroke(width=0)
+ word.add_updater(lambda m: m.shift(SMALL_BUFF * DOWN))
+
+ self.add(incidence)
+ self.play(
+ ShowCreation(dl_arc),
+ UpdateFromAlphaFunc(
+ VMobject(),
+ lambda m, a: incidence.set_fill(opacity=a),
+ remover=True
+ ),
+ )
+ self.wait()
+ self.add(reflection)
+ self.play(
+ ShowCreation(dr_arc),
+ UpdateFromAlphaFunc(
+ VMobject(),
+ lambda m, a: reflection.set_fill(opacity=a),
+ remover=True
+ ),
+ )
+ self.wait()
+
+ # Change dr wire angle
+ # dr_wire.suspend_updating()
+ dr_wire.clear_updaters()
+ for angle in [20 * DEGREES, -20 * DEGREES]:
+ self.play(
+ Rotate(
+ dr_wire, angle,
+ about_point=dr_wire.get_end(),
+ run_time=2,
+ ),
+ )
+ self.play(
+ *self.get_shooting_beam_anims(self.ghost_trajectory),
+ *self.get_shooting_beam_anims(self.d_trajectory),
+ )
+ self.wait()
+
+ def show_reflecting_beam(self):
+ self.play(
+ *self.get_shooting_beam_anims(self.trajectory),
+ *self.get_shooting_beam_anims(self.ghost_trajectory),
+ )
+ self.wait()
diff --git a/active_projects/clacks/solution2/pi_creature_scenes.py b/active_projects/clacks/solution2/pi_creature_scenes.py
index 0189ea5f2..fe8c3a0b4 100644
--- a/active_projects/clacks/solution2/pi_creature_scenes.py
+++ b/active_projects/clacks/solution2/pi_creature_scenes.py
@@ -49,7 +49,16 @@ class OnAnsweringTwice(TeacherStudentsScene):
class AskAboutEqualMassMomentumTransfer(TeacherStudentsScene):
def construct(self):
- pass
+ self.student_says("Why?")
+ self.change_student_modes("confused", "confused")
+ self.wait()
+ self.play(
+ RemovePiCreatureBubble(self.students[2]),
+ self.teacher.change, "raise_right_hand"
+ )
+ self.change_all_student_modes("pondering")
+ self.look_at(self.hold_up_spot + 2 * UP)
+ self.wait(5)
class ComplainAboutRelevanceOfAnalogy(TeacherStudentsScene):
@@ -76,3 +85,34 @@ class ComplainAboutRelevanceOfAnalogy(TeacherStudentsScene):
self.hold_up_spot + UP,
)
self.wait(3)
+
+
+class ReplaceOneTrickySceneWithAnother(TeacherStudentsScene):
+ def construct(self):
+ self.student_says(
+ "This replaces one tricky\\\\problem with another",
+ student_index=1,
+ target_mode="sassy",
+ added_anims=[self.teacher.change, "happy"],
+ )
+ self.change_student_modes("erm", "sassy", "angry")
+ self.wait(4)
+ self.play(
+ RemovePiCreatureBubble(self.students[1]),
+ self.teacher.change, "raise_right_hand",
+ self.get_student_changes(*3 * ["pondering"])
+ )
+ self.look_at(self.hold_up_spot + 2 * UP)
+ self.wait(5)
+
+
+class NowForTheGoodPart(TeacherStudentsScene):
+ def construct(self):
+ self.teacher_says(
+ r"Now for the \\ good part!",
+ target_mode="hooray",
+ added_anims=[self.get_student_changes(
+ "hooray", "surprised", "happy"
+ )],
+ )
+ self.wait(2)
diff --git a/active_projects/clacks/solution2/position_phase_space.py b/active_projects/clacks/solution2/position_phase_space.py
index 2df542693..3903c87ee 100644
--- a/active_projects/clacks/solution2/position_phase_space.py
+++ b/active_projects/clacks/solution2/position_phase_space.py
@@ -18,7 +18,7 @@ class PositionPhaseSpaceScene(Scene):
"block1_config": {
"mass": 10,
"distance": 9,
- "velocity": 1,
+ "velocity": -1,
"width": 1.6,
},
"block2_config": {
@@ -47,17 +47,36 @@ class PositionPhaseSpaceScene(Scene):
"radius": 0.05,
},
"ps_d2_label_vect": RIGHT,
+ "ps_x_line_config": {
+ "color": GREEN,
+ "stroke_width": 2,
+ },
+ "ps_y_line_config": {
+ "color": RED,
+ "stroke_width": 2,
+ },
"clack_sound": "clack",
"mirror_line_class": Line,
"mirror_line_style": {
"stroke_color": WHITE,
"stroke_width": 1,
},
- "d1_eq_e2_line_color": GREEN_SCREEN,
+ "d1_eq_d2_line_color": MAROON_B,
+ "d1_eq_d2_tex": "d1 = d2",
"trajectory_style": {
"stroke_color": YELLOW,
"stroke_width": 2,
- }
+ },
+ "ps_velocity_vector_length": 0.75,
+ "ps_velocity_vector_config": {
+ "color": PINK,
+ "rectangular_stem_width": 0.025,
+ "tip_length": 0.15,
+ },
+ "block_velocity_vector_length_multiple": 2,
+ "block_velocity_vector_config": {
+ "color": PINK,
+ },
}
def setup(self):
@@ -186,6 +205,7 @@ class PositionPhaseSpaceScene(Scene):
v1 = self.block1.velocity
w2 = self.block2.get_width()
h2 = self.block2.get_height()
+ start_d1, start_d2 = self.get_ds()
ps_speed = np.sqrt(m1) * abs(v1)
theta = np.arctan(np.sqrt(m2 / m1))
@@ -202,7 +222,7 @@ class PositionPhaseSpaceScene(Scene):
point[1] / np.sqrt(m2),
)
- ps_point = ds_to_ps_point(*self.get_ds())
+ ps_point = ds_to_ps_point(start_d1, start_d2)
wedge_corner = ds_to_ps_point(w2, w2)
ps_point -= wedge_corner
y = ps_point[1]
@@ -225,38 +245,38 @@ class PositionPhaseSpaceScene(Scene):
clack_data.append((time, loc1, loc2))
return clack_data
- def get_clack_flashes(self):
- pass # TODO
-
def tie_ps_point_to_time_tracker(self):
- time_tracker = self.get_time_tracker(
- time=self.total_sliding_time
- )
+ if not hasattr(self, "sliding_time_tracker"):
+ self.sliding_time_tracker = self.get_time_tracker()
def update_ps_point(p):
- time = time_tracker.get_value()
+ time = self.sliding_time_tracker.get_value()
ds = self.time_to_ds(time)
p.move_to(self.ds_to_point(*ds))
+
self.ps_point.add_updater(update_ps_point)
- self.add(time_tracker, self.ps_point)
+ self.add(self.sliding_time_tracker, self.ps_point)
def add_clack_flashes(self):
- clack_data = self.get_clack_data()
- self.clack_times = [
- time for (time, loc1, loc2) in clack_data
- ]
- self.block_flashes = ClackFlashes([
- (loc1, time)
- for (time, loc1, loc2) in clack_data
- ])
- self.ps_flashes = ClackFlashes([
- (loc2, time)
- for (time, loc1, loc2) in clack_data
- ])
- self.add(
- self.block_flashes,
- self.ps_flashes,
- )
+ if hasattr(self, "flash_anims"):
+ self.add(*self.flash_anims)
+ else:
+ clack_data = self.get_clack_data()
+ self.clack_times = [
+ time for (time, loc1, loc2) in clack_data
+ ]
+ self.block_flashes = ClackFlashes([
+ (loc1, time)
+ for (time, loc1, loc2) in clack_data
+ ])
+ self.ps_flashes = ClackFlashes([
+ (loc2, time)
+ for (time, loc1, loc2) in clack_data
+ ])
+ self.flash_anims = [self.block_flashes, self.ps_flashes]
+ for anim in self.flash_anims:
+ anim.get_time = self.sliding_time_tracker.get_value
+ self.add(*self.flash_anims)
def get_continually_building_trajectory(self):
trajectory = VMobject()
@@ -296,22 +316,23 @@ class PositionPhaseSpaceScene(Scene):
self.add(self.get_continually_building_trajectory())
def end_sliding(self):
+ self.continual_update(dt=0)
self.ps_point.clear_updaters()
- self.remove(self.time_tracker)
- to_remove = ["block_flashes", "ps_flashes"]
- for attr in to_remove:
- if hasattr(self, attr):
- self.remove(getattr(self, attr))
+ if hasattr(self, "sliding_time_tracker"):
+ self.remove(self.sliding_time_tracker)
+ if hasattr(self, "flash_anims"):
+ self.remove(*self.flash_anims)
if hasattr(self, "trajectory"):
self.trajectory.suspend_updating()
- total_time = self.time_tracker.get_value()
- self.total_sliding_time += total_time
+ old_total_sliding_time = self.total_sliding_time
+ new_total_sliding_time = self.sliding_time_tracker.get_value()
+ self.total_sliding_time = new_total_sliding_time
for time in self.clack_times:
- if time < total_time:
- offset = total_time - time
+ if old_total_sliding_time < time < new_total_sliding_time:
+ offset = time - new_total_sliding_time
self.add_sound(
"clack",
- time_offset=-offset,
+ time_offset=offset,
)
def slide(self, time, stop_condition=None):
@@ -409,21 +430,21 @@ class PositionPhaseSpaceScene(Scene):
def get_axes_labels(self, axes, with_sqrts=None):
if with_sqrts is None:
with_sqrts = self.rescale_coordinates
- x_label = TexMobject("x = ", "d_1")
- y_label = TexMobject("y = ", "d_2")
+ x_label = TexMobject("x", "=", "d_1")
+ y_label = TexMobject("y", "=", "d_2")
labels = VGroup(x_label, y_label)
if with_sqrts:
additions = map(TexMobject, [
"\\sqrt{m_1}", "\\sqrt{m_2}"
])
for label, addition in zip(labels, additions):
- addition.move_to(label[1], DL)
- label[1].next_to(
+ addition.move_to(label[2], DL)
+ label[2].next_to(
addition, RIGHT, SMALL_BUFF,
aligned_edge=DOWN
)
addition[2:].set_color(BLUE)
- label.add(addition)
+ label.submobjects.insert(2, addition)
x_label.next_to(axes.x_axis.get_right(), DL, MED_SMALL_BUFF)
y_label.next_to(axes.y_axis.get_top(), DR, MED_SMALL_BUFF)
for label in labels:
@@ -447,8 +468,7 @@ class PositionPhaseSpaceScene(Scene):
y_axis_point[1] = point[1]
return DashedLine(
y_axis_point, point,
- color=GREEN,
- stroke_width=2,
+ **self.ps_x_line_config,
)
self.x_line = updating_mobject_from_func(get_x_line)
return self.x_line
@@ -461,8 +481,7 @@ class PositionPhaseSpaceScene(Scene):
x_axis_point[0] = point[0]
return DashedLine(
x_axis_point, point,
- color=RED,
- stroke_width=2,
+ **self.ps_y_line_config,
)
self.y_line = updating_mobject_from_func(get_y_line)
return self.y_line
@@ -570,11 +589,11 @@ class PositionPhaseSpaceScene(Scene):
end = self.ds_to_point(15, 15)
line = self.d1_eq_d2_line = self.mirror_line_class(start, end)
line.set_style(**self.mirror_line_style)
- line.set_color(self.d1_eq_e2_line_color)
+ line.set_color(self.d1_eq_d2_line_color)
return self.d1_eq_d2_line
def get_d1_eq_d2_label(self):
- label = TexMobject("d1 = d2")
+ label = TexMobject(self.d1_eq_d2_tex)
label.scale(0.75)
line = self.d1_eq_d2_line
point = interpolate(
@@ -611,14 +630,60 @@ class PositionPhaseSpaceScene(Scene):
)
return time_tracker
+ # Things associated with velocity
+ def get_ps_velocity_vector(self, trajectory):
+ vector = Vector(
+ self.ps_velocity_vector_length * LEFT,
+ **self.ps_velocity_vector_config,
+ )
+
+ def update_vector(v):
+ anchors = trajectory.get_anchors()
+ index = len(anchors) - 2
+ vect = np.array(ORIGIN)
+ while get_norm(vect) == 0 and index > 0:
+ p0, p1 = anchors[index:index + 2]
+ vect = p1 - p0
+ index -= 1
+ angle = angle_of_vector(vect)
+ point = self.ps_point.get_location()
+ v.set_angle(angle)
+ v.shift(point - v.get_start())
+ vector.add_updater(update_vector)
+ self.ps_velocity_vector = vector
+ return vector
+
+ def get_block_velocity_vectors(self, ps_vect):
+ blocks = self.blocks
+ vectors = VGroup(*[
+ Vector(LEFT, **self.block_velocity_vector_config)
+ for x in range(2)
+ ])
+ # TODO: Put in config
+ vectors[0].set_color(GREEN)
+ vectors[1].set_color(RED)
+
+ def update_vectors(vs):
+ v_2d = ps_vect.get_vector()[:2]
+ v_2d *= self.block_velocity_vector_length_multiple
+ for v, coord, block in zip(vs, v_2d, blocks):
+ v.put_start_and_end_on(ORIGIN, coord * RIGHT)
+ start = block.get_edge_center(v.get_vector())
+ v.shift(start)
+ vectors.add_updater(update_vectors)
+
+ self.block_velocity_vectors = vectors
+ return vectors
+
class IntroducePositionPhaseSpace(PositionPhaseSpaceScene):
CONFIG = {
"rescale_coordinates": False,
+ "d1_eq_d2_tex": "x = y",
"block1_config": {
"velocity": 1.5,
},
- "slide_wait_time": 30,
+ "slide_wait_time": 12,
}
def setup(self):
@@ -711,7 +776,6 @@ class IntroducePositionPhaseSpace(PositionPhaseSpaceScene):
sliding_trajectory = self.get_continually_building_trajectory()
self.add(sliding_trajectory, self.ps_dot)
self.wait(self.slide_wait_time)
- self.end_sliding()
def show_w2_line(self):
line = self.d2_eq_w2_line
@@ -719,7 +783,9 @@ class IntroducePositionPhaseSpace(PositionPhaseSpaceScene):
self.play(ShowCreation(line))
self.play(FadeInFromDown(label))
- self.wait()
+ self.wait(self.slide_wait_time)
+ self.end_sliding()
+ self.wait(self.slide_wait_time)
class SpecialShowPassingFlash(ShowPassingFlash):
@@ -745,6 +811,7 @@ class EqualMassCase(PositionPhaseSpaceScene):
"velocity": 1.5,
},
"rescale_coordinates": False,
+ "d1_eq_d2_tex": "x = y",
}
def setup(self):
@@ -922,14 +989,14 @@ class EqualMassCase(PositionPhaseSpaceScene):
d1, d2 = self.get_ds()
d1 = int(d1)
d2 = int(d2)
- w2 = self.block2.get_width()
+ # w2 = self.block2.get_width()
ps_point = self.ps_point
points = []
while d1 > d2:
points.append(self.ds_to_point(d1, d2))
d1 -= 1
- while d2 >= int(w2):
+ while d2 >= 1:
points.append(self.ds_to_point(d1, d2))
d2 -= 1
points += list(reversed(points))[1:]
@@ -1104,7 +1171,7 @@ class FailedAngleRelation(PositionPhaseSpaceScene):
result = VGroup(
TextMobject("Angle of incidence"),
TexMobject("\\ne").rotate(90 * DEGREES),
- TextMobject("Angle of refraction")
+ TextMobject("Angle of reflection")
)
result.arrange_submobjects(DOWN)
result.set_stroke(BLACK, 5, background=True)
@@ -1186,7 +1253,10 @@ class RescaleCoordinates(PositionPhaseSpaceScene, MovingCameraScene):
self.play(
Transform(
axes.labels[index],
- new_axes_labels[index][:2],
+ VGroup(
+ *new_axes_labels[index][:2],
+ new_axes_labels[index][3]
+ ),
),
GrowFromCenter(new_axes_labels[index][2])
)
@@ -1282,7 +1352,7 @@ class RescaleCoordinates(PositionPhaseSpaceScene, MovingCameraScene):
rect = ScreenRectangle(height=FRAME_HEIGHT + 10)
inner_rect = ScreenRectangle(height=FRAME_HEIGHT)
rect.add_subpath(inner_rect.points[::-1])
- rect.set_fill(DARK_GREY, opacity=1)
+ rect.set_fill("#333333", opacity=1)
frame = self.camera_frame
self.begin_sliding()
@@ -1328,10 +1398,978 @@ class RescaleCoordinatesMass64(RescaleCoordinatesMass16):
"block2_config": {"distance": 3},
}
+
+class RescaleCoordinatesMass100(RescaleCoordinatesMass16):
+ CONFIG = {
+ "block1_config": {
+ "mass": 100,
+ "distance": 6,
+ "velocity": 0.5,
+ },
+ "block2_config": {"distance": 2},
+ "wait_time": 25,
+ }
+
+
+class IntroduceVelocityVector(PositionPhaseSpaceScene, MovingCameraScene):
+ CONFIG = {
+ "zoom": True,
+ "ps_x_line_config": {
+ "color": WHITE,
+ "stroke_width": 1,
+ "stroke_opacity": 0.5,
+ },
+ "ps_y_line_config": {
+ "color": WHITE,
+ "stroke_width": 1,
+ "stroke_opacity": 0.5,
+ },
+ "axes_center": 6 * LEFT + 0.65 * DOWN,
+ "slide_time": 20,
+ "new_vect_config": {
+ "tip_length": 0.1,
+ "rectangular_stem_width": 0.02,
+ }
+ }
+
+ def setup(self):
+ MovingCameraScene.setup(self)
+ PositionPhaseSpaceScene.setup(self)
+ self.add(
+ self.floor,
+ self.wall,
+ self.blocks,
+ self.axes,
+ self.d1_eq_d2_line,
+ self.d1_eq_d2_label,
+ self.d2_eq_w2_line,
+ self.x_line,
+ self.y_line,
+ self.ps_dot,
+ )
+
def construct(self):
- self.put_into_frame()
+ self.show_velocity_vector()
+ self.contrast_with_physical_velocities()
+ self.zoom_in_on_vector()
+ self.break_down_components()
+ self.zoom_out()
+ self.relate_x_dot_y_dot_to_v1_v2()
+ self.calculate_magnitude()
+ self.let_process_play_out()
+
+ def show_velocity_vector(self):
+ self.slide(2)
+ ps_vect = self.get_ps_velocity_vector(self.trajectory)
+ self.play(GrowArrow(ps_vect))
+ self.play(ShowCreationThenFadeAround(ps_vect))
+ self.wait()
+
+ def contrast_with_physical_velocities(self):
+ ps_vect = self.ps_velocity_vector
+ block_vectors = self.get_block_velocity_vectors(ps_vect)
+
+ self.play(LaggedStart(GrowArrow, block_vectors))
+ self.play(Rotating(
+ ps_vect,
+ angle=TAU,
+ about_point=ps_vect.get_start(),
+ run_time=5,
+ rate_func=smooth,
+ ))
+ self.wait()
+ self.slide_until(lambda: self.get_d2() < 2.5)
+
+ def zoom_in_on_vector(self):
+ if not self.zoom:
+ self.wait(3)
+ return
+ ps_vect = self.ps_velocity_vector
+ new_vect = Arrow(
+ ps_vect.get_start(),
+ ps_vect.get_end(),
+ buff=0,
+ **self.new_vect_config
+ )
+ new_vect.match_style(ps_vect)
+
+ camera_frame = self.camera_frame
+ camera_frame.save_state()
+ point = self.ps_point.get_location()
+ point += MED_SMALL_BUFF * DOWN
+ self.play(
+ camera_frame.scale, 0.25, {"about_point": point},
+ Transform(ps_vect, new_vect),
+ run_time=2,
+ )
+ self.wait()
+
+ def break_down_components(self):
+ # Create vectors
+ ps_vect = self.ps_velocity_vector
+ start = ps_vect.get_start()
+ end = ps_vect.get_end()
+ ul_corner = np.array(start)
+ dr_corner = np.array(start)
+ ul_corner[0] = end[0]
+ dr_corner[1] = end[1]
+
+ x_vect = Arrow(
+ start, ul_corner,
+ buff=0,
+ **self.new_vect_config
+ )
+ y_vect = Arrow(
+ start, dr_corner,
+ buff=0,
+ **self.new_vect_config
+ )
+ x_vect.set_fill(GREEN, opacity=0.75)
+ y_vect.set_fill(RED, opacity=0.75)
+ vects = VGroup(x_vect, y_vect)
+
+ # Projection lines
+ x_line, y_line = [
+ DashedLine(
+ ps_vect.get_end(),
+ vect.get_end(),
+ dashed_segment_length=0.01,
+ color=vect.get_color(),
+ )
+ for vect in (x_vect, y_vect)
+ ]
+ self.projection_lines = VGroup(x_line, y_line)
+
+ # Vector labels
+ dx_label = TexMobject("\\frac{dx}{dt}")
+ dy_label = TexMobject("\\frac{dy}{dt}")
+ labels = VGroup(dx_label, dy_label)
+ for label, arrow, direction in zip(labels, vects, [UP, RIGHT]):
+ label.scale(0.25)
+ buff = 0.25 * SMALL_BUFF
+ label.next_to(arrow, direction, buff=buff)
+ label.set_stroke(BLACK, 3, background=True)
+
+ if not self.zoom:
+ self.grow_labels(labels)
+
+ self.play(
+ TransformFromCopy(ps_vect, x_vect),
+ ShowCreation(x_line),
+ )
+ self.play(FadeInFrom(dx_label, 0.25 * DOWN))
+ self.wait()
+ self.play(
+ TransformFromCopy(ps_vect, y_vect),
+ ShowCreation(y_line),
+ )
+ self.play(FadeInFrom(dy_label, 0.25 * LEFT))
+ self.wait()
+
+ # Ask about dx_dt
+ randy = Randolph()
+ randy.match_height(dx_label)
+ randy.next_to(dx_label, LEFT, SMALL_BUFF)
+ randy.change("confused", dx_label)
+ randy.save_state()
+ randy.fade(1)
+ randy.change("plain")
+
+ self.play(Restore(randy))
+ self.play(WiggleOutThenIn(dx_label))
+ self.play(Blink(randy))
+ self.play(FadeOut(randy))
+
+ self.derivative_labels = labels
+ self.component_vectors = vects
+
+ def zoom_out(self):
+ if not self.zoom:
+ self.wait(2)
+ return
+ labels = self.derivative_labels
+ self.play(
+ Restore(self.camera_frame),
+ ApplyFunction(self.grow_labels, labels),
+ run_time=2
+ )
+
+ def relate_x_dot_y_dot_to_v1_v2(self):
+ derivative_labels = self.derivative_labels.copy()
+ dx_label, dy_label = derivative_labels
+ x_label, y_label = self.axes.labels
+ m_part = x_label[2]
+ block1 = self.block1
+ block_vectors = self.block_velocity_vectors
+
+ x_eq = x_label[1]
+ dx_eq = TexMobject("=")
+ dx_eq.next_to(
+ x_eq, DOWN,
+ buff=LARGE_BUFF,
+ aligned_edge=RIGHT,
+ )
+ for label in derivative_labels:
+ label.generate_target()
+ label.target.scale(1.5)
+ dx_label.target.next_to(dx_eq, LEFT)
+ dx_rhs = TexMobject("\\sqrt{m_1}", "v_1")
+ dx_rhs[0][2:].set_color(BLUE)
+ dx_rhs[1].set_color(GREEN)
+ dx_rhs.next_to(dx_eq, RIGHT)
+ alt_v1 = dx_rhs[1].copy()
+
+ self.play(ShowCreationThenFadeAround(x_label))
+ self.play(MoveToTarget(dx_label))
+ self.play(TransformFromCopy(x_eq, dx_eq))
+ self.wait()
+ self.play(
+ VGroup(block1, m_part).shift, SMALL_BUFF * UP,
+ rate_func=wiggle,
+ )
+ self.wait()
+ self.d1_brace.update()
+ self.d1_label.update()
+ self.play(
+ ShowCreationThenFadeAround(x_label[3]),
+ FadeIn(self.d1_brace),
+ FadeIn(self.d1_label),
+ )
+ self.wait()
+ self.play(
+ TransformFromCopy(x_label[3], dx_rhs[1]),
+ TransformFromCopy(x_label[2], VGroup(dx_rhs[0])),
+ )
+ block_vectors.suspend_updating()
+ self.play(alt_v1.next_to, block_vectors[0], UP, SMALL_BUFF)
+ self.play(
+ Rotate(
+ block_vectors[0], 10 * DEGREES,
+ about_point=block_vectors[0].get_start(),
+ rate_func=wiggle,
+ run_time=1,
+ )
+ )
+ self.play(FadeOut(alt_v1))
+ block_vectors.resume_updating()
+ self.wait()
+
+ # dy_label
+ y_eq = y_label[1]
+ dy_eq = TexMobject("=")
+ dy_eq.next_to(y_eq, DOWN, LARGE_BUFF)
+ dy_label.target.next_to(dy_eq, LEFT)
+ dy_rhs = TexMobject("\\sqrt{m_2}", "v_2")
+ dy_rhs[0][2:].set_color(BLUE)
+ dy_rhs[1].set_color(RED)
+ dy_rhs.next_to(dy_eq, RIGHT)
+ VGroup(dy_label.target, dy_eq, dy_rhs).align_to(y_label, LEFT)
+ alt_v2 = dy_rhs[1].copy()
+ self.play(MoveToTarget(dy_label))
+ self.play(
+ Write(dy_eq),
+ Write(dy_rhs),
+ )
+ self.play(alt_v2.next_to, block_vectors[1], UP, SMALL_BUFF)
+ self.wait()
+ self.play(FadeOut(alt_v2))
+ self.wait()
+
+ self.derivative_equations = VGroup(
+ VGroup(dx_label, dx_eq, dx_rhs),
+ VGroup(dy_label, dy_eq, dy_rhs),
+ )
+
+ def calculate_magnitude(self):
+ corner_rect = Rectangle(
+ stroke_color=WHITE,
+ stroke_width=1,
+ fill_color=BLACK,
+ fill_opacity=1,
+ height=2.5,
+ width=8.5,
+ )
+ corner_rect.to_corner(UR, buff=0)
+
+ ps_vect = self.ps_velocity_vector
+ big_ps_vect = Arrow(
+ ps_vect.get_start(), ps_vect.get_end(),
+ buff=0,
+ )
+ big_ps_vect.match_style(ps_vect)
+ big_ps_vect.scale(1.5)
+ magnitude_bars = TexMobject("||", "||")
+ magnitude_bars.match_height(
+ big_ps_vect, stretch=True
+ )
+ rhs_scale_val = 0.8
+ rhs = TexMobject(
+ "=\\sqrt{"
+ "\\left( dx/dt \\right)^2 + "
+ "\\left( dy/dt \\right)^2"
+ "}"
+ )
+ rhs.scale(rhs_scale_val)
+ group = VGroup(
+ magnitude_bars[0], big_ps_vect,
+ magnitude_bars[1], rhs
+ )
+ group.arrange_submobjects(RIGHT)
+ group.next_to(corner_rect.get_corner(UL), DR)
+
+ new_rhs = TexMobject(
+ "=", "\\sqrt", "{m_1(v_1)^2 + m_2(v_2)^2}",
+ tex_to_color_map={
+ "m_1": BLUE,
+ "m_2": BLUE,
+ "v_1": GREEN,
+ "v_2": RED,
+ }
+ )
+ new_rhs.scale(rhs_scale_val)
+ new_rhs.next_to(rhs, DOWN, aligned_edge=LEFT)
+
+ final_rhs = TexMobject(
+ "=", "\\sqrt{2(\\text{Kinetic energy})}"
+ )
+ final_rhs.scale(rhs_scale_val)
+ final_rhs.next_to(new_rhs, DOWN, aligned_edge=LEFT)
+
+ self.play(
+ FadeIn(corner_rect),
+ TransformFromCopy(ps_vect, big_ps_vect)
+ )
+ self.play(Write(magnitude_bars), Write(rhs[0]))
+ self.wait()
+ self.play(Write(rhs[1:]))
+ self.wait()
+ self.play(FadeInFrom(new_rhs, UP))
+ for equation in self.derivative_equations:
+ self.play(ShowCreationThenFadeAround(equation))
+ self.wait()
+ self.play(FadeInFrom(final_rhs, UP))
+ self.wait()
+
+ def let_process_play_out(self):
+ self.play(*map(FadeOut, [
+ self.projection_lines,
+ self.derivative_labels,
+ self.component_vectors,
+ self.d1_brace,
+ self.d1_label,
+ ]))
+ self.add(self.blocks, self.derivative_equations)
+ self.blocks.resume_updating()
+ self.slide(self.slide_time)
+
+ #
+ def grow_labels(self, labels):
+ for label, vect in zip(labels, [DOWN, LEFT]):
+ p = label.get_edge_center(vect)
+ p += SMALL_BUFF * vect
+ label.scale(2.5, about_point=p)
+ return labels
+
+
+class IntroduceVelocityVectorWithoutZoom(IntroduceVelocityVector):
+ CONFIG = {
+ "zoom": False,
+ }
+
+
+class ShowMomentumConservation(IntroduceVelocityVector):
+ CONFIG = {
+ "ps_velocity_vector_length": 1.25,
+ "block_velocity_vector_length_multiple": 1,
+ "block1_config": {
+ "distance": 7,
+ },
+ "axes_config": {
+ "y_max": 11,
+ },
+ "axes_center": 6.5 * LEFT + 1.2 * DOWN,
+ "floor_y": -3.75,
+ "wait_time": 15,
+ }
+
+ def construct(self):
+ self.add_velocity_vectors()
+ self.contrast_d1_d2_line_with_xy_line()
+ self.rearrange_for_slope()
+ self.up_to_first_collision()
+ self.ask_what_next()
+ self.show_conservation_of_momentum()
+ self.show_rate_of_change_vector()
+ self.show_sqrty_m_vector()
+ self.show_dot_product()
+ self.show_same_angles()
+ self.show_horizontal_bounce()
+ self.let_process_play_out()
+
+ def add_velocity_vectors(self):
+ self.slide(1)
+ self.ps_vect = self.get_ps_velocity_vector(self.trajectory)
+ self.block_vectors = self.get_block_velocity_vectors(self.ps_vect)
+ self.play(
+ GrowArrow(self.ps_vect),
+ LaggedStart(GrowArrow, self.block_vectors, run_time=1),
+ )
+ self.add(self.ps_vect, self.block_vectors)
+ def contrast_d1_d2_line_with_xy_line(self):
+ line = self.d1_eq_d2_line
+ label = self.d1_eq_d2_label
+ label.to_edge(RIGHT, buff=1.1)
+ label.shift(0.65 * DOWN)
+
+ xy_line = line.copy()
+ xy_line.set_stroke(YELLOW, 3)
+ xy_line.set_angle(45 * DEGREES)
+ xy_label = TexMobject("x = y")
+ xy_label.next_to(ORIGIN, DOWN, SMALL_BUFF)
+ xy_label.rotate(45 * DEGREES, about_point=ORIGIN)
+ xy_label.shift(xy_line.point_from_proportion(0.2))
+ self.xy_group = VGroup(xy_line, xy_label)
+
+ self.play(
+ ShowPassingFlash(
+ line.copy().set_stroke(YELLOW, 4)
+ ),
+ Write(label),
+ )
+ self.play(
+ TransformFromCopy(line, xy_line, run_time=2)
+ )
+ self.play(Write(xy_label))
+ self.wait()
+
+ def rearrange_for_slope(self):
+ eqs = VGroup(*reversed(self.axes.labels)).copy()
+ y_eq, x_eq = eqs
+ for eq in eqs:
+ point = VectorizedPoint(eq[1].get_center())
+ eq.submobjects.insert(1, point)
+ eq.submobjects[3] = eq[3].submobjects[0]
+ eq.generate_target()
+ eqs_targets = VGroup(*[eq.target for eq in eqs])
+
+ new_eqs = VGroup(
+ TexMobject("{y", "\\over", "\\sqrt{m_2}}", "=", "d_2"),
+ TexMobject("{x", "\\over", "\\sqrt{m_1}}", "=", "d_1"),
+ )
+ new_x_eq, new_y_eq = new_eqs
+ # Shuffle to align with x_eq and y_eq
+ for new_eq in new_eqs:
+ new_eq[2][2:].set_color(BLUE)
+ new_eq.submobjects = [new_eq[i] for i in [0, 1, 3, 2, 4]]
+
+ eqs_targets.arrange_submobjects(DOWN, buff=LARGE_BUFF)
+ eqs_targets.move_to(RIGHT).to_edge(UP)
+ for eq, new_eq in zip(eqs_targets, new_eqs):
+ new_eq.move_to(eq)
+
+ self.play(LaggedStart(MoveToTarget, eqs, lag_ratio=0.7))
+ self.play(*[
+ Transform(
+ eq, new_eq,
+ path_arc=-90 * DEGREES,
+ )
+ for eq, new_eq in zip(eqs, new_eqs)
+ ])
+ self.wait()
+
+ # Shuffle back
+ for eq in eqs:
+ eq[2][2:].set_color(BLUE)
+ eq.submobjects = [eq[i] for i in [0, 1, 3, 2, 4]]
+
+ # Set equal
+ equals = TexMobject("=")
+ for eq in eqs:
+ eq.generate_target()
+ VGroup(
+ x_eq.target[4],
+ x_eq.target[3],
+ x_eq.target[:3],
+ ).arrange_submobjects(RIGHT)
+ for p1, p2 in zip(x_eq, x_eq.target):
+ p2.align_to(p1, DOWN)
+ group = VGroup(y_eq.target, equals, x_eq.target)
+ group.arrange_submobjects(RIGHT)
+ x_eq.target.align_to(y_eq.target, DOWN)
+ equals.align_to(y_eq.target[3], DOWN)
+ group.to_edge(UP, buff=MED_SMALL_BUFF)
+ group.to_edge(RIGHT, buff=3)
+
+ self.play(
+ MoveToTarget(y_eq),
+ MoveToTarget(x_eq, path_arc=90 * DEGREES),
+ GrowFromCenter(equals)
+ )
+ self.wait()
+
+ # Simplify
+ final_eq = TexMobject(
+ "y", "=",
+ "{\\sqrt{m_2}", "\\over", "\\sqrt{m_1}}",
+ "x",
+ )
+ for part in final_eq.get_parts_by_tex("sqrt"):
+ part[2:].set_color(BLUE)
+ m_part = final_eq[2:5]
+
+ final_eq.next_to(group, DOWN)
+ final_eq.shift(0.4 * UP)
+ movers = VGroup(
+ y_eq[0], equals.submobjects[0],
+ y_eq[2], y_eq[1], x_eq[2],
+ x_eq[0]
+ ).copy()
+ for mover, part in zip(movers, final_eq):
+ mover.target = part
+ self.play(
+ LaggedStart(
+ MoveToTarget, movers,
+ path_arc=30 * DEGREES,
+ lag_ratio=0.9
+ ),
+ VGroup(x_eq, equals, y_eq).scale,
+ 0.7, {"about_edge": UP},
+ )
+ self.remove(movers)
+ self.add(final_eq)
+ self.wait()
+
+ # Highlight slope
+ flash_line = self.d1_eq_d2_line.copy()
+ flash_line.set_stroke(YELLOW, 5)
+ self.play(ShowPassingFlash(flash_line))
+ self.play(ShowCreationThenFadeAround(m_part))
+ self.wait()
+
+ # Tuck away slope in mind
+ slope = m_part.copy()
+ slope.generate_target()
+ randy = Randolph(height=1.5)
+ randy.next_to(final_eq, LEFT, MED_SMALL_BUFF)
+ randy.align_to(self.d2_eq_w2_line, DOWN)
+ bubble = ThoughtBubble(
+ height=1.3, width=1.3, direction=RIGHT,
+ )
+ bubble.pin_to(randy)
+ slope.target.scale(0.5)
+ slope.target.move_to(bubble.get_bubble_center())
+ randy.change("pondering", slope.target)
+ randy.save_state()
+ randy.change("plane")
+ randy.fade(1)
+
+ self.play(
+ Restore(randy),
+ Write(bubble),
+ MoveToTarget(slope)
+ )
+ self.play(Blink(randy))
+
+ self.thinking_on_slope_group = VGroup(
+ randy, bubble, slope,
+ )
+
+ self.to_fade = VGroup(
+ eqs, equals, final_eq,
+ self.thinking_on_slope_group,
+ self.xy_group,
+ )
+
+ def up_to_first_collision(self):
+ self.begin_sliding()
+ self.play(FadeOut(self.to_fade))
+ self.wait_until(
+ lambda: abs(self.ps_velocity_vector.get_vector()[1]) > 0.01
+ )
+ self.end_sliding()
+ self.wait(3 + 3 / 60) # Final cut reasons
+
+ def ask_what_next(self):
+ ps_vect = self.ps_velocity_vector
+ question = TextMobject("What next?")
+ question.set_background_stroke(color=BLACK, width=3)
+ question.next_to(self.ps_point, UP)
+
+ self.play(FadeInFrom(question, DOWN))
+ ps_vect.suspend_updating()
+ angles = [0.75 * PI, -0.5 * PI, -0.25 * PI]
+ for last_angle, angle in zip(np.cumsum([0] + angles), angles):
+ # This is dumb and shouldn't be needed
+ ps_vect.rotate(last_angle, about_point=ps_vect.get_start())
+ target = ps_vect.copy()
+ target.rotate(
+ angle,
+ about_point=ps_vect.get_start()
+ )
+ self.play(
+ Transform(
+ ps_vect, target,
+ path_arc=angle
+ ),
+ )
+ ps_vect.resume_updating()
+
+ self.whats_next_question = question
+
+ def show_conservation_of_momentum(self):
+ equation = self.get_momentum_equation()
+
+ # Main equation
+ self.play(FadeInFromDown(equation))
+ for part in equation[:2], equation[3:5]:
+ outline = part.copy()
+ outline.set_fill(opacity=0)
+ outline.set_stroke(YELLOW, 3)
+ self.play(ShowPassingFlash(
+ outline,
+ run_time=1.5
+ ))
+ self.wait(0.5)
+
+ # Dot product
+ dot_product = self.get_dot_product()
+ dot_product.next_to(equation, DOWN)
+ sqrty_m_array = dot_product[0]
+
+ x_label, y_label = self.axes.labels
+
+ self.play(
+ FadeOut(self.whats_next_question),
+ FadeIn(dot_product),
+ Transform(
+ x_label[2].copy(),
+ sqrty_m_array.get_entries()[0],
+ remover=True,
+ ),
+ Transform(
+ y_label[2].copy(),
+ sqrty_m_array.get_entries()[1],
+ remover=True,
+ ),
+ )
+
+ self.momentum_equation = equation
+ self.dot_product = dot_product
+
+ def show_rate_of_change_vector(self):
+ ps_vect = self.ps_velocity_vector
+ original_d_array = self.dot_product[2]
+
+ d_array = original_d_array.copy()
+ d_array.generate_target()
+ d_array.scale(0.75)
+ d_array.add_updater(lambda m: m.next_to(
+ ps_vect.get_end(),
+ np.sign(ps_vect.get_vector()[0]) * RIGHT,
+ SMALL_BUFF
+ ))
+
+ self.play(TransformFromCopy(original_d_array, d_array))
+ self.wait()
+
+ self.d_array = d_array
+
+ def show_sqrty_m_vector(self):
+ original_sqrty_m_array = self.dot_product[0]
+ sqrty_m_vector = Arrow(
+ self.ds_to_point(0, 0),
+ # self.ds_to_point(1, 1),
+ self.ds_to_point(2, 2),
+ buff=0,
+ color=YELLOW,
+ )
+
+ sqrty_m_array = original_sqrty_m_array.deepcopy()
+ sqrty_m_array.scale(0.75)
+ sqrty_m_array.next_to(
+ sqrty_m_vector.get_end(), UP, SMALL_BUFF
+ )
+
+ rise = DashedLine(
+ sqrty_m_vector.get_end(),
+ sqrty_m_vector.get_corner(DR),
+ color=RED,
+ )
+ run = DashedLine(
+ sqrty_m_vector.get_corner(DR),
+ sqrty_m_vector.get_start(),
+ color=GREEN,
+ )
+ sqrty_m_array.add_background_to_entries()
+ run_label, rise_label = sqrty_m_array.get_entries().copy()
+ rise_label.next_to(rise, RIGHT, SMALL_BUFF)
+ run_label.next_to(run, DOWN, SMALL_BUFF)
+
+ randy_group = self.thinking_on_slope_group
+ randy_group.align_to(self.d2_eq_w2_line, DOWN)
+ randy_group.to_edge(LEFT)
+ randy_group.shift(2 * RIGHT)
+
+ self.play(GrowArrow(sqrty_m_vector))
+ self.play(TransformFromCopy(
+ original_sqrty_m_array, sqrty_m_array,
+ ))
+ self.play(FadeIn(randy_group))
+ self.play(
+ ShowCreation(rise),
+ TransformFromCopy(
+ sqrty_m_array.get_entries()[1],
+ rise_label,
+ ),
+ )
+ self.add(run, randy_group)
+ self.play(
+ ShowCreation(run),
+ TransformFromCopy(
+ sqrty_m_array.get_entries()[0],
+ run_label,
+ ),
+ )
+ self.wait()
+ self.play(FadeOut(randy_group))
+ self.play(FadeOut(VGroup(
+ rise, run, rise_label, run_label,
+ )))
+
+ # move to ps_point
+ point = self.ps_point.get_location()
+ sqrty_m_vector.generate_target()
+ sqrty_m_vector.target.shift(
+ point - sqrty_m_vector.get_start()
+ )
+ sqrty_m_array.generate_target()
+ sqrty_m_array.target.next_to(
+ sqrty_m_vector.target.get_end(),
+ RIGHT, SMALL_BUFF,
+ )
+ sqrty_m_array.target.shift(SMALL_BUFF * UP)
+ self.play(
+ MoveToTarget(sqrty_m_vector),
+ MoveToTarget(sqrty_m_array),
+ run_time=2
+ )
+
+ self.sqrty_m_vector = sqrty_m_vector
+ self.sqrty_m_array = sqrty_m_array
+
+ def show_dot_product(self):
+ # Highlight arrays
+ d_array = self.d_array
+ big_d_array = self.dot_product[2]
+ m_array = self.sqrty_m_array
+ big_m_array = self.dot_product[0]
+
+ self.play(
+ ShowCreationThenFadeAround(big_d_array),
+ ShowCreationThenFadeAround(d_array),
+ )
+ self.play(
+ ShowCreationThenFadeAround(big_m_array),
+ ShowCreationThenFadeAround(m_array),
+ )
+
+ # Before and after
+ ps_vect = self.ps_velocity_vector
+ theta = np.arctan(np.sqrt(self.block2.mass / self.block1.mass))
+ self.theta = theta
+
+ ps_vect.suspend_updating()
+ kwargs = {"about_point": ps_vect.get_start()}
+ for x in range(2):
+ for u in [-1, 1]:
+ ps_vect.rotate(u * 2 * theta, **kwargs)
+ self.continual_update(dt=0)
+ self.wait()
+ ps_vect.resume_updating()
+
+ # Circle
+ circle = Circle(
+ radius=ps_vect.get_length(),
+ arc_center=ps_vect.get_start(),
+ color=RED,
+ stroke_width=1,
+ )
+ self.play(
+ Rotating(
+ ps_vect,
+ about_point=ps_vect.get_start(),
+ run_time=5,
+ rate_func=lambda t: smooth(t, 3),
+ ),
+ FadeIn(circle),
+ )
+ self.wait()
+
+ self.ps_vect_circle = circle
+
+ def show_same_angles(self):
+ # circle = self.ps_vect_circle
+ ps_vect = self.ps_velocity_vector
+ ps_point = self.ps_point
+ point = ps_point.get_center()
+ ghost_ps_vect = ps_vect.copy()
+ ghost_ps_vect.clear_updaters()
+ ghost_ps_vect.set_fill(opacity=0.5)
+ theta = self.theta
+ ghost_ps_vect.rotate(
+ -2 * theta,
+ about_point=ghost_ps_vect.get_start(),
+ )
+
+ arc1 = Arc(
+ start_angle=PI,
+ angle=theta,
+ arc_center=point,
+ radius=0.5,
+ color=WHITE,
+ )
+ arc2 = arc1.copy()
+ arc2.rotate(theta, about_point=point)
+ arc3 = arc1.copy()
+ arc3.rotate(PI, about_point=point)
+ arc1.set_color(BLUE)
+
+ line_pair = VGroup(*[
+ Line(point, point + LEFT).rotate(
+ angle, about_point=point
+ )
+ for angle in [0, theta]
+ ])
+ line_pair.set_stroke(width=0)
+
+ ps_vect.suspend_updating()
+ self.play(
+ ShowCreation(arc1),
+ FadeIn(ghost_ps_vect)
+ )
+ self.wait()
+ self.play(
+ Rotate(ps_vect, 2 * theta, about_point=point)
+ )
+ self.begin_sliding()
+ ps_vect.resume_updating()
+ self.play(GrowFromPoint(arc2, point))
+ self.wait(0.5)
+ self.end_sliding()
+ self.play(
+ TransformFromCopy(arc1, arc3, path_arc=-PI),
+ Rotate(line_pair, -PI, about_point=point),
+ UpdateFromAlphaFunc(
+ line_pair, lambda m, a: m.set_stroke(
+ width=there_and_back(a)**0.5
+ )
+ ),
+ )
+ # Show light beam along trajectory
+ self.show_trajectory_beam_bounce()
+ self.wait()
+
+ # TODO: Add labels for angles?
+
+ self.play(FadeOut(VGroup(
+ self.ps_vect_circle, ghost_ps_vect, arc1
+ )))
+
+ def show_horizontal_bounce(self):
+ self.slide_until(
+ lambda: self.ps_velocity_vector.get_vector()[1] > 0
+ )
+ point = self.ps_point.get_location()
+ theta = self.theta
+ arc1 = Arc(
+ start_angle=0,
+ angle=2 * theta,
+ radius=0.5,
+ arc_center=point,
+ )
+ arc2 = arc1.copy()
+ arc2.rotate(PI - 2 * theta, about_point=point)
+ arcs = VGroup(arc1, arc2)
+
+ self.slide(0.5)
+ self.play(LaggedStart(
+ FadeInFromLarge, arcs,
+ lag_ratio=0.75,
+ ))
+ self.show_trajectory_beam_bounce()
+
+ def let_process_play_out(self):
+ self.slide(self.wait_time)
+ self.wait(10) # Just to be sure...
+
+ #
+ def show_trajectory_beam_bounce(self, n_times=2):
+ # Show light beam along trajectory
+ beam = self.trajectory.copy()
+ beam.clear_updaters()
+ beam.set_stroke(YELLOW, 3)
+ for x in range(n_times):
+ self.play(ShowPassingFlash(
+ beam,
+ run_time=2,
+ rate_func=bezier([0, 0, 1, 1])
+ ))
+
+ def get_momentum_equation(self):
+ equation = TexMobject(
+ "m_1", "v_1", "+", "m_2", "v_2",
+ "=", "\\text{const.}",
+ tex_to_color_map={
+ "m_1": BLUE,
+ "m_2": BLUE,
+ "v_1": RED,
+ "v_2": RED,
+ }
+ )
+ equation.to_edge(UP, buff=MED_SMALL_BUFF)
+ return equation
+
+ def get_dot_product(self,
+ m1="\\sqrt{m_1}", m2="\\sqrt{m_2}",
+ d1="dx/dt", d2="dy/dt"):
+ sqrty_m = Matrix([[m1], [m2]])
+ deriv_array = Matrix([[d1], [d2]])
+ for entry in sqrty_m.get_entries():
+ if "sqrt" in entry.get_tex_string():
+ entry[2:].set_color(BLUE)
+ for matrix in sqrty_m, deriv_array:
+ matrix.add_to_back(BackgroundRectangle(matrix))
+ matrix.get_brackets().scale(0.9)
+ matrix.set_height(1.25)
+ dot = TexMobject("\\cdot")
+ rhs = TexMobject("= \\text{const.}")
+ dot_product = VGroup(
+ sqrty_m, dot, deriv_array, rhs
+ )
+ dot_product.arrange_submobjects(RIGHT, buff=SMALL_BUFF)
+ return dot_product
+
+
+class JustTheProcessNew(PositionPhaseSpaceScene):
+ CONFIG = {
+ "block1_config": {
+ "mass": 16,
+ "velocity": -2
+ },
+ "wait_time": 10,
+ }
+
+ def setup(self):
+ super().setup()
+ self.add(
+ self.floor,
+ self.wall,
+ self.blocks,
+ self.axes,
+ self.d1_eq_d2_line,
+ self.d2_eq_w2_line,
+ )
-class NewSceneName(Scene):
def construct(self):
- pass
+ self.slide(self.wait_time)
diff --git a/active_projects/clacks/solution2/simple_scenes.py b/active_projects/clacks/solution2/simple_scenes.py
index 42bfdb7b7..e877c8b26 100644
--- a/active_projects/clacks/solution2/simple_scenes.py
+++ b/active_projects/clacks/solution2/simple_scenes.py
@@ -1,15 +1,841 @@
from big_ol_pile_of_manim_imports import *
+from old_projects.lost_lecture import ShowWord
+from active_projects.clacks.solution2.mirror_scenes import ReflectWorldThroughMirrorNew
+from active_projects.clacks.question import Thumbnail
-class LastVideoWrapper(Scene):
+class WrapperScene(Scene):
+ CONFIG = {
+ "title": "Title",
+ "shade_of_grey": "#333333"
+ }
+
def construct(self):
- title = TextMobject("Last time...")
+ title = TextMobject(self.title)
title.scale(1.5)
title.to_edge(UP)
- rect = ScreenRectangle(height=6)
- rect.next_to(title, DOWN)
+ big_rect = self.get_big_rect()
+ screen_rect = self.get_screen_rect()
+ screen_rect.next_to(title, DOWN)
+
+ self.add(big_rect, screen_rect)
self.play(
- FadeInFromDown(title),
- ShowCreation(rect)
+ FadeIn(big_rect),
+ FadeInFrom(title, DOWN),
+ FadeInFrom(screen_rect, UP),
)
self.wait()
+
+ def get_big_rect(self):
+ big_rect = FullScreenFadeRectangle()
+ big_rect.set_fill(self.shade_of_grey, 1)
+ return big_rect
+
+ def get_screen_rect(self, height=6):
+ screen_rect = ScreenRectangle(height=height)
+ screen_rect.set_fill(BLACK, 1)
+ return screen_rect
+
+
+class ComingUpWrapper(WrapperScene):
+ CONFIG = {"title": "Coming up..."}
+
+
+class LastVideoWrapper(WrapperScene):
+ CONFIG = {"title": "Last time..."}
+
+
+class LeftEdge(Scene):
+ CONFIG = {
+ "text": "Left edge",
+ "vect": LEFT,
+ }
+
+ def construct(self):
+ words = TextMobject(self.text)
+ arrow = Vector(self.vect)
+ arrow.match_width(words)
+ arrow.next_to(words, DOWN)
+
+ self.play(
+ FadeInFromDown(words),
+ GrowArrow(arrow)
+ )
+ self.wait()
+
+
+class RightEdge(LeftEdge):
+ CONFIG = {
+ "text": "Right edge",
+ "vect": RIGHT,
+ }
+
+
+class NoteOnEnergyLostToSound(Scene):
+ def construct(self):
+ self.add(TextMobject(
+ "Yeah yeah, the clack sound\\\\"
+ "would require energy, but\\\\"
+ "don't let accuracy get in the\\\\"
+ "way of delight!",
+ alignment="",
+ ))
+
+
+class DotProductVideoWrapper(WrapperScene):
+ CONFIG = {"title": "Dot product"}
+
+
+class Rectangle(Scene):
+ def construct(self):
+ rect = ScreenRectangle(height=FRAME_HEIGHT - 0.25)
+ rect.set_stroke(WHITE, 6)
+ self.add(rect)
+
+
+class ShowRectangleCreation(Scene):
+ def construct(self):
+ rect = ScreenRectangle(height=2)
+ rect.set_stroke(YELLOW, 6)
+ self.play(ShowCreation(rect))
+ self.play(FadeOut(rect))
+
+
+class ShowDotProductMeaning(Scene):
+ def construct(self):
+ v_vect = Vector(2 * RIGHT, color=YELLOW)
+ w_vect = Vector(3 * RIGHT, color=PINK)
+ dot = Dot(color=RED)
+ dot.shift(DOWN)
+
+ v_vect.angle_tracker = ValueTracker()
+ w_vect.angle_tracker = ValueTracker()
+
+ def update_vect(vect):
+ target = vect.angle_tracker.get_value()
+ vect.rotate(target - vect.get_angle())
+ vect.shift(dot.get_center() - vect.get_start())
+
+ v_vect.add_updater(update_vect)
+ w_vect.add_updater(update_vect)
+
+ v_label = TexMobject("\\vec{\\textbf{v}}")
+ v_label.vect = v_vect
+ w_label = TexMobject("\\vec{\\textbf{w}}")
+ w_label.vect = w_vect
+ for label in v_label, w_label:
+ label.match_color(label.vect)
+ label.set_stroke(BLACK, 5, background=True)
+
+ def update_label(label):
+ target = np.array(label.vect.get_end())
+ target += 0.25 * normalize(label.vect.get_vector())
+ label.move_to(target)
+
+ v_label.add_updater(update_label)
+ w_label.add_updater(update_label)
+
+ title = TexMobject(
+ "\\vec{\\textbf{w}}",
+ "\\cdot",
+ "\\vec{\\textbf{v}}",
+ "=",
+ "||", "\\vec{\\textbf{w}}", "||",
+ "\\cdot",
+ "||", "\\vec{\\textbf{v}}", "||",
+ "\\cdot",
+ "\\cos(\\theta)"
+ )
+ title.set_color_by_tex_to_color_map({
+ "textbf{v}": v_vect.get_color(),
+ "textbf{w}": w_vect.get_color(),
+ })
+ title.to_edge(UP)
+
+ def get_w_line():
+ center = dot.get_center()
+ direction = w_vect.get_vector()
+ return Line(
+ center - 3 * direction,
+ center + 3 * direction,
+ stroke_color=LIGHT_GREY,
+ stroke_width=1,
+ )
+ w_line = updating_mobject_from_func(get_w_line)
+
+ def get_proj_v():
+ center = dot.get_center()
+ v = v_vect.get_vector()
+ w = w_vect.get_vector()
+ w_unit = normalize(w)
+ result = Vector(np.dot(v, w_unit) * w_unit)
+ result.set_fill(v_vect.get_color(), 0.5)
+ result.shift(center - result.get_start())
+ return result
+ proj_v = updating_mobject_from_func(get_proj_v)
+
+ def get_proj_line():
+ return DashedLine(
+ v_vect.get_end(),
+ proj_v.get_end(),
+ stroke_width=1,
+ dashed_segment_length=0.025,
+ )
+ proj_line = updating_mobject_from_func(get_proj_line)
+
+ template_line = Line(LEFT, RIGHT)
+
+ def get_vect_brace(vect):
+ brace = Brace(template_line, UP, buff=SMALL_BUFF)
+ brace.set_width(vect.get_length(), stretch=True)
+ angle = vect.get_angle() % TAU
+ if angle < PI:
+ angle += PI
+ brace.rotate(angle, about_point=ORIGIN)
+ brace.shift(vect.get_center())
+ return brace
+ w_brace = updating_mobject_from_func(
+ lambda: get_vect_brace(w_vect)
+ )
+ proj_v_brace = updating_mobject_from_func(
+ lambda: get_vect_brace(proj_v)
+ )
+
+ def get_arc():
+ center = dot.get_center()
+ a1 = w_vect.get_angle()
+ a2 = v_vect.get_angle()
+ arc = Arc(
+ start_angle=a1,
+ angle=a2 - a1,
+ radius=0.5,
+ arc_center=center,
+ )
+ theta = TexMobject("\\theta")
+ p = arc.point_from_proportion(0.5)
+ theta.move_to(
+ center + 1.5 * (p - center)
+ )
+ return VGroup(arc, theta)
+ arc = updating_mobject_from_func(get_arc)
+
+ self.add(
+ title[:3],
+ w_vect, v_vect, dot,
+ w_label, v_label,
+ )
+ self.play(
+ v_vect.angle_tracker.set_value, 170 * DEGREES,
+ w_vect.angle_tracker.set_value, 45 * DEGREES,
+ run_time=2,
+ )
+ self.wait()
+ w_brace.update()
+ self.play(
+ GrowFromCenter(w_brace),
+ Write(title[3:7])
+ )
+
+ self.add(w_line, w_vect, w_label, dot)
+ self.play(ShowCreation(w_line))
+ proj_v.update()
+ self.play(
+ ShowCreation(proj_line),
+ TransformFromCopy(v_vect, proj_v),
+ )
+ self.add(proj_v, proj_line, dot)
+ proj_v_brace.update()
+ self.play(
+ GrowFromCenter(proj_v_brace),
+ FadeInFromDown(title[7:])
+ )
+ arc.update()
+ self.play(Write(arc))
+ self.wait()
+
+ for angle in [135, 225, 270, 90, 150]:
+ self.play(
+ v_vect.angle_tracker.set_value, angle * DEGREES,
+ run_time=2
+ )
+ self.wait()
+
+
+class FinalComment(Scene):
+ def construct(self):
+ self.add(TextMobject(
+ "Thoughts on what ending should go here?\\\\"
+ "See the Patreon post."
+ ))
+
+
+class FourtyFiveDegreeLine(Scene):
+ CONFIG = {
+ "angle": 45 * DEGREES,
+ "label_config": {
+ "num_decimal_places": 0,
+ "unit": "^\\circ",
+ "label_height": 0.3,
+ },
+ "degrees": True
+ }
+
+ def construct(self):
+ angle = self.angle
+ arc = Arc(angle, radius=1)
+ label = DecimalNumber(0, **self.label_config)
+ label.set_height(self.label_config["label_height"])
+ label.next_to(arc, RIGHT)
+ label.shift(0.5 * SMALL_BUFF * UP)
+ line1 = Line(ORIGIN, 3 * RIGHT)
+ line2 = line1.copy()
+
+ if self.degrees:
+ target_value = int(angle / DEGREES)
+ else:
+ target_value = angle
+
+ self.add(line1, label)
+ self.play(
+ ChangeDecimalToValue(label, target_value),
+ ShowCreation(arc),
+ Rotate(line2, angle, about_point=ORIGIN)
+ )
+ self.wait()
+
+
+class ArctanSqrtPoint1Angle(FourtyFiveDegreeLine):
+ CONFIG = {
+ "angle": np.arctan(np.sqrt(0.1)),
+ }
+
+
+class AskAboutAddingThetaToItself(Scene):
+ CONFIG = {
+ "theta": np.arctan(0.25),
+ "wait_time": 0.25,
+ "wedge_radius": 3,
+ "theta_symbol_scale_val": 0.5,
+ "number_height": 0.2,
+ }
+
+ def construct(self):
+ theta = self.theta
+ groups = self.get_groups(theta)
+ horizon = self.get_horizon()
+ counter = ValueTracker(0)
+ dynamic_ineq = self.get_dynamic_inequality(counter)
+ semicircle = self.get_semicircle()
+
+ self.add(horizon)
+ self.add(dynamic_ineq)
+
+ for n in range(len(groups)):
+ counter.set_value(n + 1)
+ if n < len(groups) - 1:
+ groups[n][-1].set_color(YELLOW)
+ if n > 0:
+ groups[n - 1][-1].set_color(WHITE)
+ self.add(groups[:n + 1])
+ self.add_sound("pen_click", gain=-20)
+ self.wait(self.wait_time)
+ self.wait(0.5)
+
+ counter.set_value(counter.get_value() - 1)
+ self.remove(groups[-1])
+ self.add_sound("pen_click", gain=-20)
+ self.wait()
+
+ self.play(ShowCreation(semicircle))
+ self.play(FadeOut(semicircle))
+
+ self.wait(3)
+
+ def get_group(self, theta):
+ # Define group
+ wedge_radius = self.wedge_radius
+ wedge = VGroup(
+ Line(ORIGIN, wedge_radius * RIGHT),
+ Line(ORIGIN, wedge_radius * RIGHT).rotate(
+ theta, about_point=ORIGIN
+ ),
+ )
+ wedge.set_stroke((WHITE, GREY), 2)
+ arc = Arc(theta, radius=1)
+ theta_symbol = TexMobject("\\theta")
+ tssv = self.theta_symbol_scale_val
+ theta_symbol.scale(tssv)
+ theta_symbol.next_to(arc, RIGHT, tssv / 2)
+ theta_symbol.shift(tssv * SMALL_BUFF * UP)
+
+ return VGroup(wedge, arc, theta_symbol)
+
+ def get_groups(self, theta):
+ group = self.get_group(theta)
+ angles = [k * theta for k in range(int(PI / theta) + 1)]
+ groups = VGroup(*[
+ group.copy().rotate(angle, about_point=ORIGIN)
+ for angle in angles
+ ])
+ # colors = it.cycle([BLUE_D, BLUE_B, BLUE_C, GREY_BROWN])
+ colors = it.cycle([BLUE_D, GREY_BROWN])
+ for n, angle, group, color in zip(it.count(1), angles, groups, colors):
+ wedge, arc, symbol = group
+ symbol.rotate(-angle)
+ arc.set_color(color)
+ number = Integer(n)
+ number.set_height(self.number_height)
+ number.move_to(center_of_mass([
+ wedge[0].get_end(),
+ wedge[1].get_end(),
+ ]))
+ group.add(number)
+ groups[-1][-1].set_color(RED)
+
+ return groups
+
+ def get_horizon(self):
+ horizon = DashedLine(5 * LEFT, 5 * RIGHT)
+ horizon.set_stroke(WHITE, 1)
+ return horizon
+
+ def get_semicircle(self):
+ return Arc(
+ start_angle=0,
+ angle=PI,
+ radius=self.wedge_radius / 2,
+ color=YELLOW,
+ stroke_width=4,
+ )
+
+ def get_inequality(self):
+ ineq = TexMobject(
+ "N", "\\cdot", "\\theta", "<",
+ "\\pi", "=", "3.1415926\\dots"
+ )
+ N = ineq.get_part_by_tex("N")
+ self.pi_symbol = ineq.get_part_by_tex("\\pi")
+ N.set_color(YELLOW)
+ # ineq[-3:].set_color(BLUE)
+
+ brace = Brace(N, UP, buff=SMALL_BUFF)
+ text = brace.get_text("Maximum", buff=SMALL_BUFF)
+ group = VGroup(ineq, brace, text)
+ group.next_to(ORIGIN, DOWN, MED_LARGE_BUFF)
+ return group
+
+ def get_dynamic_inequality(self, counter):
+ multiple = Integer(0)
+ dot = TexMobject("\\cdot")
+ theta_tex = TexMobject("({:.2f})".format(self.theta))
+ eq = TexMobject("=")
+ value = DecimalNumber(0)
+ ineq = TexMobject("<")
+ pi = TexMobject("\\pi", "=", "3.1415926\\dots")
+ # pi.set_color(BLUE)
+ group = VGroup(
+ multiple, dot, theta_tex,
+ eq, value,
+ ineq, pi
+ )
+ group.arrange_submobjects(RIGHT, buff=0.2)
+ group.next_to(ORIGIN, DOWN, buff=LARGE_BUFF)
+ theta_brace = Brace(group[2], DOWN, buff=SMALL_BUFF)
+ theta_symbol = theta_brace.get_tex("\\theta")
+ group.add(theta_brace, theta_symbol)
+ # group.align_to(self.pi_symbol, RIGHT)
+
+ def get_count():
+ return int(counter.get_value())
+
+ def get_product():
+ return get_count() * self.theta
+
+ def is_greater_than_pi():
+ return get_product() > PI
+
+ def get_color():
+ return RED if is_greater_than_pi() else YELLOW
+
+ def get_ineq():
+ result = TexMobject(
+ ">" if is_greater_than_pi() else "<"
+ )
+ result.set_color(get_color())
+ result.move_to(ineq)
+ return result
+ dynamic_ineq = updating_mobject_from_func(get_ineq)
+ group.remove(ineq)
+ group.add(dynamic_ineq)
+
+ multiple.add_updater(lambda m: m.set_value(get_count()))
+ multiple.add_updater(lambda m: m.next_to(dot, LEFT, 0.2))
+ multiple.add_updater(lambda m: m.set_color(get_color()))
+ value.add_updater(lambda m: m.set_value(get_product()))
+
+ return group
+
+
+class AskAboutAddingThetaToItselfThetaPoint1(AskAboutAddingThetaToItself):
+ CONFIG = {
+ "theta": 0.1,
+ "wait_time": 0.1,
+ "theta_symbol_scale_val": 0.25,
+ "number_height": 0.15,
+ }
+
+
+class AskAboutAddingThetaToItselfThetaPoint2(AskAboutAddingThetaToItself):
+ CONFIG = {
+ "theta": 0.2,
+ "wait_time": 0.1,
+ }
+
+
+class FinalFormula(Scene):
+ def construct(self):
+ text = TextMobject("Final answer: ")
+ t2c_map = {
+ "\\theta": BLUE,
+ "m_1": GREEN,
+ "m_2": RED,
+ }
+
+ formula = TexMobject(
+ "\\left\\lfloor",
+ "{\\pi", "\\over", "\\theta}",
+ "\\right\\rfloor"
+ )
+ formula.set_color_by_tex_to_color_map(t2c_map)
+ group = VGroup(text, formula)
+ group.arrange_submobjects(RIGHT)
+ group.scale(1.5)
+ group.to_edge(UP)
+
+ self.play(Write(text))
+ self.play(FadeInFrom(formula))
+ self.play(ShowCreationThenFadeAround(formula))
+ self.wait()
+
+ theta_eq = TexMobject(
+ "\\theta", "=", "\\arctan", "\\left(",
+ "\\sqrt",
+ "{{m_2", "\\over", "m_1}}",
+ "\\right)"
+ )
+ theta_eq.set_color_by_tex_to_color_map(t2c_map)
+ theta_eq.scale(1.5)
+ theta_eq.next_to(group, DOWN, MED_LARGE_BUFF)
+
+ self.play(TransformFromCopy(
+ formula.get_part_by_tex("\\theta"),
+ theta_eq.get_part_by_tex("\\theta"),
+ ))
+ self.play(Write(theta_eq[1:]))
+ self.wait()
+
+
+class ReviewWrapper(WrapperScene):
+ CONFIG = {"title": "To review:"}
+
+
+class SurprisedRandy(Scene):
+ def construct(self):
+ randy = Randolph()
+ self.play(randy.change, "surprised", 3 * UR)
+ self.play(Blink(randy))
+ self.play(randy.change, "confused")
+ self.play(Blink(randy))
+ self.wait()
+
+
+class TwoSolutionsWrapper(WrapperScene):
+ def construct(self):
+ big_rect = self.get_big_rect()
+ screen_rects = VGroup(*[
+ self.get_screen_rect(height=3)
+ for x in range(2)
+ ])
+ screen_rects.arrange_submobjects(RIGHT, buff=LARGE_BUFF)
+ title = TextMobject("Two solutions")
+ title.scale(1.5)
+ title.to_edge(UP)
+ screen_rects.next_to(title, DOWN, LARGE_BUFF)
+
+ # pi creatures
+ pis = VGroup(
+ Randolph(color=BLUE_D),
+ Randolph(color=BLUE_E),
+ Randolph(color=BLUE_B),
+ Mortimer().scale(1.2)
+ )
+ pis.set_height(2)
+ pis.arrange_submobjects(RIGHT, buff=MED_LARGE_BUFF)
+ pis.to_edge(DOWN, buff=SMALL_BUFF)
+
+ self.add(big_rect, title, pis)
+ self.play(
+ LaggedStart(
+ ShowCreation, screen_rects.copy().set_fill(opacity=0),
+ lag_ratio=0.8
+ ),
+ LaggedStart(
+ FadeIn, screen_rects,
+ lag_ratio=0.8
+ ),
+ LaggedStart(
+ ApplyMethod, pis,
+ lambda pi: (pi.change, "pondering", screen_rects[0])
+ ),
+ )
+ self.play(Blink(random.choice(pis)))
+ self.play(LaggedStart(
+ ApplyMethod, pis,
+ lambda pi: (pi.change, "thinking", screen_rects[1])
+ ))
+ self.play(Blink(random.choice(pis)))
+ self.wait()
+
+
+class FinalQuote(Scene):
+ def construct(self):
+ quote_text = """
+ A change of perspective\\\\
+ is worth 80 IQ points.
+ """
+ quote_parts = [s for s in quote_text.split(" ") if s]
+ quote = TextMobject(
+ *quote_parts,
+ )
+ quote.scale(1.2)
+ quote.shift(2 * RIGHT + UP)
+
+ image = ImageMobject("AlanKay")
+ image.set_height(6)
+ image.to_corner(UL)
+ image.shift(2 * LEFT + 0.5 * UP)
+ name = TextMobject("Alan Kay")
+ name.scale(1.5)
+ name.next_to(image, DOWN)
+ name.shift_onto_screen()
+
+ self.play(
+ FadeInFromDown(image),
+ Write(name),
+ )
+ self.wait()
+
+ for word in quote:
+ self.play(ShowWord(word))
+ self.wait(0.005 * len(word)**1.5)
+ self.wait()
+
+
+class EndScreen(PatreonEndScreen):
+ CONFIG = {
+ "specific_patrons": [
+ "1stViewMaths",
+ "Adam Kozak",
+ "Adrian Robinson",
+ "Alexis Olson",
+ "Ali Yahya",
+ "Andreas Benjamin Brössel",
+ "Andrew Busey",
+ "Ankalagon",
+ "Antonio Juarez",
+ "Arjun Chakroborty",
+ "Art Ianuzzi",
+ "Arthur Zey",
+ "Awoo",
+ "Bernd Sing",
+ "Bob Sanderson",
+ "Boris Veselinovich",
+ "Brian Staroselsky",
+ "Britt Selvitelle",
+ "Burt Humburg",
+ "Chad Hurst",
+ "Charles Southerland",
+ "Chris Connett",
+ "Christian Kaiser",
+ "Clark Gaebel",
+ "Cooper Jones",
+ "D. Sivakumar",
+ "Danger Dai",
+ "Dave B",
+ "Dave Kester",
+ "dave nicponski",
+ "David Clark",
+ "David Gow",
+ "Delton Ding",
+ "Devarsh Desai",
+ "eaglle",
+ "emptymachine",
+ "Eric Younge",
+ "Eryq Ouithaqueue",
+ "Evan Phillips",
+ "Federico Lebron",
+ "Florian Chudigiewitsch",
+ "Giovanni Filippi",
+ "Graham",
+ "Hal Hildebrand",
+ "Hitoshi Yamauchi",
+ "J",
+ "j eduardo perez",
+ "Jacob Magnuson",
+ "Jameel Syed",
+ "James Hughes",
+ "Jan Pijpers",
+ "Jason Hise",
+ "Jeff Linse",
+ "Jeff Straathof",
+ "John Griffith",
+ "John Haley",
+ "John Shaughnessy",
+ "John V Wertheim",
+ "Jonathan Eppele",
+ "Jonathan Wilson",
+ "Jordan Scales",
+ "Joseph John Cox",
+ "Joseph Kelly",
+ "Juan Benet",
+ "Kai-Siang Ang",
+ "Kanan Gill",
+ "Kaustuv DeBiswas",
+ "L0j1k",
+ "Lee Redden",
+ "Linh Tran",
+ "Luc Ritchie",
+ "Ludwig Schubert",
+ "Lukas -krtek.net- Novy",
+ "Lukas Biewald",
+ "Magister Mugit",
+ "Magnus Dahlström",
+ "Magnus Lysfjord",
+ "Mark B Bahu",
+ "Mark Heising",
+ "Mathew Bramson",
+ "Mathias Jansson",
+ "Matt Langford",
+ "Matt Roveto",
+ "Matt Russell",
+ "Matthew Cocke",
+ "Mauricio Collares",
+ "Michael Faust",
+ "Michael Hardel",
+ "Mike Coleman",
+ "Mustafa Mahdi",
+ "Márton Vaitkus",
+ "Nathan Jessurun",
+ "Nero Li",
+ "Omar Zrien",
+ "Owen Campbell-Moore",
+ "Peter Ehrnstrom",
+ "Peter Mcinerney",
+ "Quantopian",
+ "Randy C. Will",
+ "Richard Barthel",
+ "Richard Burgmann",
+ "Richard Comish",
+ "Ripta Pasay",
+ "Rish Kundalia",
+ "Robert Teed",
+ "Roobie",
+ "Roy Larson",
+ "Ryan Atallah",
+ "Ryan Williams",
+ "Samuel D. Judge",
+ "Scott Gray",
+ "Scott Walter, Ph.D.",
+ "Sindre Reino Trosterud",
+ "soekul",
+ "Solara570",
+ "Song Gao",
+ "Stevie Metke",
+ "Ted Suzman",
+ "Tihan Seale",
+ "Valeriy Skobelev",
+ "Vassili Philippov",
+ "Xavier Bernard",
+ "Yana Chernobilsky",
+ "Yaw Etse",
+ "YinYangBalance.Asia",
+ "Yu Jun",
+ "Zach Cardwell",
+ ],
+ }
+
+
+class ClacksSolution2Thumbnail(Scene):
+ def construct(self):
+ self.add_scene1()
+ self.add_scene2()
+
+ arrow = TexMobject("\\Updownarrow")
+ arrow.set_height(2)
+ arrow.set_color(YELLOW)
+ arrow.set_stroke(Color("red"), 2, background=True)
+ self.add(arrow)
+
+ def add_scene1(self):
+ scene1 = Thumbnail(
+ sliding_blocks_config={
+ "block1_config": {
+ "label_text": "$100^{d}$ kg",
+ "distance": 8,
+ },
+ }
+ )
+ VGroup(*scene1.mobjects).shift(0.9 * DOWN)
+ scene1.remove(scene1.question)
+ self.add(*scene1.mobjects)
+
+ rect = FullScreenFadeRectangle(fill_opacity=1)
+ rect.shift(FRAME_HEIGHT * UP / 2)
+ self.add(rect)
+
+ def add_scene2(self):
+ scene2 = ReflectWorldThroughMirrorNew(
+ skip_animations=True,
+ file_writer_config={
+ "write_to_movie": False,
+ },
+ end_at_animation_number=18,
+ center=1.5 * UP,
+ )
+ worlds = VGroup(scene2.world, *scene2.reflected_worlds)
+ mirrors = VGroup(*[rw[1] for rw in worlds])
+ mirrors.set_stroke(width=5)
+ randys = VGroup(*[rw[-1] for rw in worlds])
+ triangles = VGroup(*[rw[0] for rw in worlds])
+ trajectories = VGroup(
+ scene2.trajectory,
+ *scene2.reflected_trajectories
+ )
+ trajectories.set_stroke(YELLOW, 1)
+
+ beams1, beams2 = [
+ scene2.get_shooting_beam_anims(
+ path,
+ max_stroke_width=20,
+ max_time_width=1,
+ num_flashes=50,
+ )
+ for path in [
+ scene2.trajectory,
+ scene2.ghost_trajectory,
+ ]
+ ]
+ beams = beams1 + beams2
+ beams = beams2
+ flashes = VGroup()
+ for beam in beams:
+ beam.update(0.5)
+ flashes.add(beam.mobject)
+
+ dot = Dot(color=YELLOW, radius=0.1)
+ dot.move_to(flashes[0].get_left())
+ flashes.add(dot)
+
+ self.add(mirrors, triangles, randys)
+ self.add(trajectories[0].set_stroke(width=3))
+ self.add(flashes)
diff --git a/active_projects/clacks/solution2/wordy_scenes.py b/active_projects/clacks/solution2/wordy_scenes.py
index c2f3a61a1..83fbbb0fd 100644
--- a/active_projects/clacks/solution2/wordy_scenes.py
+++ b/active_projects/clacks/solution2/wordy_scenes.py
@@ -1,4 +1,5 @@
from big_ol_pile_of_manim_imports import *
+from active_projects.clacks.solution2.position_phase_space import ShowMomentumConservation
class ConnectionToOptics(Scene):
@@ -145,7 +146,7 @@ class ConnectionToOptics(Scene):
title = VGroup(*map(TextMobject, [
"Angle of\\\\Incidence",
"=",
- "Angle of\\\\Refraction",
+ "Angle of\\\\Reflection",
])).arrange_submobjects(RIGHT)
title.set_color(YELLOW)
h_line = Line(LEFT, RIGHT)
@@ -203,3 +204,115 @@ class ConnectionToOptics(Scene):
class ConnectionToOpticsTransparent(ConnectionToOptics):
pass
+
+
+class RearrangeMomentumEquation(ShowMomentumConservation):
+ def setup(self):
+ pass # Don't build all the things
+
+ def construct(self):
+ self.add(FullScreenFadeRectangle(
+ fill_color=BLACK,
+ fill_opacity=0.95,
+ ))
+ self.show_initial_dot_product()
+ self.show_with_x_and_y()
+
+ def show_initial_dot_product(self):
+ equation = self.get_momentum_equation()
+ dot_product = self.get_dot_product(
+ "m_1", "m_2", "v_1", "v_2"
+ )
+ dot_product.next_to(equation, DOWN, LARGE_BUFF)
+ m_array, dot, v_array, rhs = dot_product
+ m_array.get_entries().set_color(BLUE)
+ v_array.get_entries().set_color(RED)
+
+ self.add(equation)
+ self.play(FadeInFromDown(VGroup(
+ m_array.get_brackets(), dot,
+ v_array.get_brackets(), rhs,
+ )))
+ self.play(TransformFromCopy(
+ equation.get_parts_by_tex("m_"),
+ m_array.get_entries(),
+ ))
+ self.play(TransformFromCopy(
+ equation.get_parts_by_tex("v_"),
+ v_array.get_entries(),
+ ))
+ self.wait()
+
+ self.simple_dot_product = dot_product
+ self.momentum_equation = equation
+
+ def show_with_x_and_y(self):
+ simple_dot_product = self.simple_dot_product
+ momentum_equation = self.momentum_equation
+
+ new_equation = TexMobject(
+ "\\sqrt{m_1}",
+ "\\left(", "\\sqrt{m_1}", "v_1", "\\right)",
+ "+", "\\sqrt{m_2}",
+ "\\left(", "\\sqrt{m_2}", "v_2", "\\right)",
+ "=", "\\text{const.}",
+ )
+ new_equation.set_color_by_tex_to_color_map({
+ "m_": BLUE,
+ "v_": RED,
+ })
+ new_equation.next_to(momentum_equation, DOWN, MED_LARGE_BUFF)
+
+ x_term = new_equation[1:5]
+ y_term = new_equation[7:11]
+ x_brace = Brace(x_term, DOWN)
+ y_brace = Brace(y_term, DOWN)
+ dx_dt = x_brace.get_tex("dx / dt")
+ dy_dt = y_brace.get_tex("dy / dt")
+
+ new_eq_group = VGroup(
+ new_equation, x_brace, y_brace, dx_dt, dy_dt
+ )
+ new_eq_group.generate_target()
+
+ new_dot_product = self.get_dot_product()
+ m_array, dot, d_array, rhs = new_dot_product
+ new_dot_product.next_to(momentum_equation, DOWN)
+ new_eq_group.target.next_to(new_dot_product, DOWN, LARGE_BUFF)
+
+ self.play(
+ FadeInFrom(new_equation, UP),
+ simple_dot_product.to_edge, DOWN, LARGE_BUFF,
+ )
+ self.wait()
+ self.play(
+ GrowFromCenter(x_brace),
+ GrowFromCenter(y_brace),
+ FadeInFrom(dx_dt, UP),
+ FadeInFrom(dy_dt, UP),
+ )
+ self.wait()
+ self.play(
+ FadeIn(VGroup(
+ m_array.get_brackets(), dot,
+ d_array.get_brackets(), rhs
+ )),
+ MoveToTarget(new_eq_group)
+ )
+ self.play(TransformFromCopy(
+ VGroup(
+ VGroup(new_equation[0]),
+ VGroup(new_equation[6]),
+ ),
+ m_array.get_entries(),
+ ))
+ self.play(TransformFromCopy(
+ VGroup(dx_dt, dy_dt),
+ d_array.get_entries(),
+ ))
+ self.wait()
+
+
+class NewSceneName(Scene):
+ def construct(self):
+ pass