Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Some supplementary animations for 3d scenes

Grant Sanderson6be9d3a21f72
diff --git a/active_projects/dandelin.py b/active_projects/dandelin.py
index 6bcc57949..722ebd8f7 100644
--- a/active_projects/dandelin.py
+++ b/active_projects/dandelin.py
@@ -1,6 +1,8 @@
from __future__ import absolute_import
from big_ol_pile_of_manim_imports import *
+from active_projects.lost_lecture import Orbiting
+
class ThinkingAboutAProof(PiCreatureScene):
def construct(self):
@@ -184,16 +186,612 @@ class MultipleDefinitionsOfAnEllipse(Scene):
definitions.next_to(title, DOWN, LARGE_BUFF)
definitions.to_edge(LEFT)
+ for definition in definitions:
+ definition.saved_state = definition.copy()
+ definition.saved_state.set_fill(LIGHT_GREY, 0.5)
+
self.play(LaggedStart(
FadeInAndShiftFromDirection, definitions,
lambda m: (m, RIGHT)
))
self.wait()
+ for definition in definitions:
+ others = filter(lambda d: d is not definition, definitions)
+ self.play(
+ definition.set_fill, WHITE, 1,
+ definition.scale, 1.2, {"about_edge": LEFT},
+ *map(Restore, others)
+ )
+ self.wait(2)
class StretchACircle(Scene):
def construct(self):
- pass
+ plane = NumberPlane(
+ x_unit_size=2,
+ y_unit_size=2
+ )
+
+ circle = Circle(radius=2)
+ circle.set_stroke(YELLOW, 5)
+ circle_ghost = circle.copy()
+ circle_ghost.set_stroke(width=1)
+
+ plane_circle_group = VGroup(plane, circle)
+ plane_circle_group.save_state()
+
+ arrows = self.get_arrows()
+
+ prop = 1.0 / 8
+ start_point = Dot(circle.point_from_proportion(prop))
+ end_point = start_point.copy().stretch(2, 0, about_point=ORIGIN)
+ end_point.stretch(0.5, 0)
+ end_point.set_color(RED)
+
+ xy = TexMobject("(x, y)")
+ cxy = TexMobject("(c \\cdot x, y)")
+ cxy[1].set_color(RED)
+ for tex in xy, cxy:
+ tex.scale(1.5)
+ tex.add_background_rectangle()
+
+ xy_arrow = Vector(DOWN, color=WHITE)
+ cxy_arrow = Vector(DL, color=WHITE)
+ xy_arrow.next_to(start_point, UP, SMALL_BUFF)
+ xy.next_to(xy_arrow, UP, SMALL_BUFF)
+ cxy_arrow.next_to(end_point, UR, SMALL_BUFF)
+ cxy.next_to(cxy_arrow, UR, SMALL_BUFF)
+
+ self.add(plane_circle_group)
+ self.wait()
+ self.play(
+ ApplyMethod(
+ plane_circle_group.stretch, 2, 0,
+ run_time=2,
+ ),
+ LaggedStart(
+ GrowArrow, arrows,
+ run_time=1,
+ lag_ratio=1
+ ),
+ )
+ self.play(FadeOut(arrows))
+ self.wait()
+ self.play(Restore(plane_circle_group))
+ self.play(
+ GrowArrow(xy_arrow),
+ Write(xy),
+ FadeInAndShiftFromDirection(start_point, UP),
+ )
+ self.wait()
+ self.add(circle_ghost)
+ self.play(
+ circle.stretch, 2, 0,
+ ReplacementTransform(start_point.copy(), end_point),
+ run_time=2
+ )
+ self.play(
+ GrowArrow(cxy_arrow),
+ Write(cxy)
+ )
+ self.wait(2)
+
+ def get_arrows(self):
+ result = VGroup()
+ for vect in [LEFT, RIGHT]:
+ for y in range(-3, 4):
+ arrow = Vector(vect)
+ arrow.move_to(2 * vect + y * UP)
+ result.add(arrow)
+ result.set_color(RED)
+ return result
+
+
+class ShowArrayOfEccentricities(Scene):
+ def construct(self):
+ eccentricities = np.linspace(0, 0.99, 6)
+ eccentricity_labels = VGroup(*map(
+ DecimalNumber, eccentricities
+ ))
+ ellipses = self.get_ellipse_row(eccentricities)
+ ellipses.set_color_by_gradient(BLUE, YELLOW)
+ ellipses.move_to(DOWN)
+
+ for label, ellipse in zip(eccentricity_labels, ellipses):
+ label.next_to(ellipse, UP)
+
+ name = TextMobject("Eccentricity")
+ name.scale(1.5)
+ name.to_edge(UP)
+ alt_name = TextMobject("(read ``squishification'')")
+ alt_name.set_color(YELLOW)
+ alt_name.next_to(name, RIGHT)
+ alt_name.shift_onto_screen()
+ name.generate_target()
+ name.target.next_to(alt_name, LEFT)
+
+ arrows = VGroup(*[
+ Arrow(name.get_bottom(), label.get_top())
+ for label in eccentricity_labels
+ ])
+ arrows.set_color_by_gradient(BLUE, YELLOW)
+
+ for label, arrow in zip(eccentricity_labels, arrows):
+ label.save_state()
+ label.fade(1)
+ label.scale(0.1)
+ label.move_to(arrow.get_start())
+
+ morty = Mortimer(height=2)
+ morty.next_to(alt_name, DOWN)
+
+ self.add(ellipses[0])
+ for e1, e2 in zip(ellipses[:-1], ellipses[1:]):
+ self.play(ReplacementTransform(
+ e1.copy(), e2,
+ path_arc=10 * DEGREES
+ ))
+ self.wait()
+
+ self.play(
+ Write(name),
+ LaggedStart(GrowArrow, arrows),
+ LaggedStart(Restore, eccentricity_labels)
+ )
+ self.wait()
+ self.play(
+ Write(alt_name),
+ MoveToTarget(name),
+ morty.change, "hooray", alt_name,
+ VFadeIn(morty),
+ )
+ self.play(Blink(morty))
+ self.play(morty.change, "thinking", ellipses)
+ self.wait()
+ self.play(Blink(morty))
+ self.wait()
+
+ circle = ellipses[0]
+ group = VGroup(*it.chain(
+ eccentricity_labels,
+ ellipses[1:],
+ arrows,
+ name,
+ alt_name,
+ [morty]
+ ))
+ self.play(
+ LaggedStart(FadeOutAndShiftDown, group),
+ circle.scale_to_fit_height, 5,
+ circle.center,
+ )
+
+ def get_ellipse(self, eccentricity, width=2):
+ result = Circle(color=WHITE)
+ result.scale_to_fit_width(width)
+ a = width / 2.0
+ c = eccentricity * a
+ b = np.sqrt(a**2 - c**2)
+ result.stretch(b / a, 1)
+ result.shift(c * LEFT)
+
+ result.eccentricity = eccentricity
+ return result
+
+ def get_ellipse_row(self, eccentricities, buff=MED_SMALL_BUFF, **kwargs):
+ result = VGroup(*[
+ self.get_ellipse(e, **kwargs)
+ for e in eccentricities
+ ])
+ result.arrange_submobjects(RIGHT, buff=buff)
+ return result
+
+ def get_eccentricity(self, ellipse):
+ """
+ Assumes that it's major/minor axes line up
+ with x and y axes
+ """
+ a = ellipse.get_width()
+ b = ellipse.get_height()
+ if b > a:
+ a, b = b, a
+ c = np.sqrt(a**2 - b**2)
+ return fdiv(c, a)
+
+
+class ShowOrbits(ShowArrayOfEccentricities):
+ CONFIG = {"camera_config": {"background_opacity": 1}}
+
+ def construct(self):
+ earth_eccentricity = 0.0167
+ comet_eccentricity = 0.9671
+ earth_orbit = self.get_ellipse(eccentricity=earth_eccentricity)
+ comet_orbit = self.get_ellipse(eccentricity=comet_eccentricity)
+ earth_orbit.scale_to_fit_height(6)
+ comet_orbit.scale_to_fit_width(
+ 0.7 * FRAME_WIDTH,
+ about_point=ORIGIN,
+ )
+
+ sun = ImageMobject("Sun")
+ earth = ImageMobject("Earth")
+ comet = ImageMobject("Comet")
+ sun.scale_to_fit_height(1)
+ earth.scale_to_fit_height(0.5)
+ comet.scale_to_fit_height(0.1)
+
+ earth_parts = VGroup(sun, earth_orbit, earth)
+
+ eccentricity_label = DecimalNumber(
+ earth_eccentricity,
+ num_decimal_places=4
+ )
+ eccentricity_equals = TextMobject(
+ "Eccentricity = "
+ )
+ earth_orbit_words = TextMobject("Earth's orbit")
+ earth_orbit_words.set_color(BLUE)
+ full_label = VGroup(
+ earth_orbit_words,
+ eccentricity_equals, eccentricity_label
+ )
+ full_label.arrange_submobjects(RIGHT, SMALL_BUFF)
+ earth_orbit_words.shift(0.5 * SMALL_BUFF * UL)
+ full_label.to_edge(UP)
+
+ comet_orbit_words = TextMobject("Halley's comet orbit")
+ comet_orbit_words.set_color(LIGHT_GREY)
+ comet_orbit_words.move_to(earth_orbit_words, RIGHT)
+
+ orbiting_earth = Orbiting(earth, sun, earth_orbit)
+ orbiting_comet = Orbiting(comet, sun, comet_orbit)
+
+ self.add(full_label, earth_orbit_words)
+ self.add(sun, earth_orbit, orbiting_earth)
+ self.wait(10)
+ orbiting_earth.rate = 1.5
+ orbiting_comet.rate = 1.5
+ self.play(
+ earth_parts.scale_to_fit_height,
+ comet_orbit.get_height() / 4.53,
+ earth_parts.shift, 3 * RIGHT
+ )
+ comet_orbit.shift(3 * RIGHT)
+ comet_orbit.save_state()
+ Transform(comet_orbit, earth_orbit).update(1)
+ self.play(
+ Restore(comet_orbit, run_time=2),
+ ChangingDecimal(
+ eccentricity_label,
+ lambda a: self.get_eccentricity(comet_orbit)
+ ),
+ FadeOutAndShift(earth_orbit_words, UP),
+ FadeInFromDown(comet_orbit_words)
+ )
+ self.add(orbiting_comet)
+ self.wait(10)
+
+
+class EccentricityInThumbtackCase(ShowArrayOfEccentricities):
+ def construct(self):
+ ellipse = self.get_ellipse(0.2, width=5)
+ ellipse_target = self.get_ellipse(0.9, width=5)
+ ellipse_target.scale(fdiv(
+ sum(self.get_abc(ellipse)),
+ sum(self.get_abc(ellipse_target)),
+ ))
+ for mob in ellipse, ellipse_target:
+ mob.center()
+ mob.set_color(BLUE)
+ thumbtack_update = self.get_thumbtack_update(ellipse)
+ ellipse_point_update = self.get_ellipse_point_update(ellipse)
+ focal_lines_update = self.get_focal_lines_update(
+ ellipse, ellipse_point_update.mobject
+ )
+ focus_to_focus_line_update = self.get_focus_to_focus_line_update(ellipse)
+ eccentricity_label = self.get_eccentricity_label()
+ eccentricity_value_update = self.get_eccentricity_value_update(
+ eccentricity_label, ellipse,
+ )
+ inner_brace_update = self.get_focus_line_to_focus_line_brace_update(
+ focus_to_focus_line_update.mobject
+ )
+ outer_lines = self.get_outer_dashed_lines(ellipse)
+ outer_lines_brace = Brace(outer_lines, DOWN)
+
+ focus_distance = TextMobject("Focus distance")
+ focus_distance.set_color(GREEN)
+ focus_distance.next_to(inner_brace_update.mobject, DOWN, SMALL_BUFF)
+ focus_distance.add_to_back(focus_distance.copy().set_stroke(BLACK, 5))
+ focus_distance_update = ContinualUpdateFromFunc(
+ focus_distance,
+ lambda m: m.scale_to_fit_width(
+ inner_brace_update.mobject.get_width(),
+ ).next_to(inner_brace_update.mobject, DOWN, SMALL_BUFF)
+ )
+ diameter = TextMobject("Diameter")
+ diameter.set_color(RED)
+ diameter.next_to(outer_lines_brace, DOWN, SMALL_BUFF)
+
+ fraction = TexMobject(
+ "{\\text{Focus distance}", "\\over",
+ "\\text{Diameter}}"
+ )
+ numerator = fraction.get_part_by_tex("Focus")
+ numerator.set_color(GREEN)
+ fraction.set_color_by_tex("Diameter", RED)
+ fraction.move_to(2 * UP)
+ fraction.to_edge(RIGHT, buff=MED_LARGE_BUFF)
+ numerator_update = ContinualUpdateFromFunc(
+ numerator,
+ lambda m: m.scale_to_fit_width(focus_distance.get_width()).next_to(
+ fraction[1], UP, MED_SMALL_BUFF
+ )
+ )
+
+ fraction_arrow = Arrow(
+ eccentricity_label.get_right(),
+ fraction.get_top() + MED_SMALL_BUFF * UP,
+ path_arc=-60 * DEGREES,
+ use_rectangular_stem=False,
+ )
+ fraction_arrow.pointwise_become_partial(fraction_arrow, 0, 0.95)
+
+ ellipse_transformation = Transform(
+ ellipse, ellipse_target,
+ rate_func=there_and_back,
+ run_time=8,
+ )
+
+ self.add(ellipse)
+ self.add(thumbtack_update)
+ self.add(ellipse_point_update)
+ self.add(focal_lines_update)
+ self.add(focus_to_focus_line_update)
+ self.add(eccentricity_label)
+ self.add(eccentricity_value_update)
+
+ self.play(ellipse_transformation)
+
+ self.add(inner_brace_update)
+ self.add(outer_lines)
+ self.add(outer_lines_brace)
+
+ self.add(fraction)
+ self.add(fraction_arrow)
+ self.add(focus_distance)
+ self.add(diameter)
+
+ self.add(focus_distance_update)
+ self.add(numerator_update)
+
+ self.play(
+ ellipse_transformation,
+ VFadeIn(inner_brace_update.mobject),
+ VFadeIn(outer_lines),
+ VFadeIn(outer_lines_brace),
+ VFadeIn(fraction),
+ VFadeIn(fraction_arrow),
+ VFadeIn(focus_distance),
+ VFadeIn(diameter),
+ )
+
+ def get_thumbtack_update(self, ellipse):
+ thumbtacks = VGroup(*[
+ self.get_thumbtack()
+ for x in range(2)
+ ])
+
+ def update_thumbtacks(thumbtacks):
+ foci = self.get_foci(ellipse)
+ for thumbtack, focus in zip(thumbtacks, foci):
+ thumbtack.move_to(focus, DR)
+ return thumbtacks
+
+ return ContinualUpdateFromFunc(thumbtacks, update_thumbtacks)
+
+ def get_ellipse_point_update(self, ellipse):
+ dot = Dot(color=RED)
+ return CycleAnimation(MoveAlongPath(
+ dot, ellipse,
+ run_time=5,
+ rate_func=None
+ ))
+
+ def get_focal_lines_update(self, ellipse, ellipse_point):
+ lines = VGroup(*[Line(LEFT, RIGHT) for x in range(2)])
+ lines.set_color_by_gradient(YELLOW, PINK)
+
+ def update_lines(lines):
+ foci = self.get_foci(ellipse)
+ Q = ellipse_point.get_center()
+ for line, focus in zip(lines, foci):
+ line.put_start_and_end_on(focus, Q)
+ return lines
+
+ return ContinualUpdateFromFunc(lines, update_lines)
+
+ def get_focus_to_focus_line_update(self, ellipse):
+ return ContinualUpdateFromFunc(
+ Line(LEFT, RIGHT, color=WHITE),
+ lambda m: m.put_start_and_end_on(*self.get_foci(ellipse))
+ )
+
+ def get_focus_line_to_focus_line_brace_update(self, line):
+ brace = Brace(Line(LEFT, RIGHT))
+ brace.add_to_back(brace.copy().set_stroke(BLACK, 5))
+ return ContinualUpdateFromFunc(
+ brace,
+ lambda b: b.match_width(line, stretch=True).next_to(
+ line, DOWN, buff=SMALL_BUFF
+ )
+ )
+
+ def get_eccentricity_label(self):
+ words = TextMobject("Eccentricity = ")
+ decimal = DecimalNumber(0, num_decimal_places=2)
+ group = VGroup(words, decimal)
+ group.arrange_submobjects(RIGHT)
+ group.to_edge(UP)
+ return group
+
+ def get_eccentricity_value_update(self, eccentricity_label, ellipse):
+ decimal = eccentricity_label[1]
+ return ContinualChangingDecimal(
+ decimal,
+ lambda a: self.get_eccentricity(ellipse)
+ )
+
+ def get_outer_dashed_lines(self, ellipse):
+ line = DashedLine(2.5 * UP, 2.5 * DOWN)
+ return VGroup(
+ line.move_to(ellipse, RIGHT),
+ line.copy().move_to(ellipse, LEFT),
+ )
+
+ #
+ def get_abc(self, ellipse):
+ a = ellipse.get_width() / 2
+ b = ellipse.get_height() / 2
+ c = np.sqrt(a**2 - b**2)
+ return a, b, c
+
+ def get_foci(self, ellipse):
+ a, b, c = self.get_abc(ellipse)
+ return [
+ ellipse.get_center() + c * RIGHT,
+ ellipse.get_center() + c * LEFT,
+ ]
+
+ def get_thumbtack(self):
+ angle = 10 * DEGREES
+ result = SVGMobject(file_name="push_pin")
+ result.scale_to_fit_height(0.5)
+ result.set_fill(LIGHT_GREY)
+ result.rotate(angle)
+ return result
+
+
+class EccentricityForSlicedConed(Scene):
+ def construct(self):
+ equation = TexMobject(
+ "\\text{Eccentricity} = ",
+ "{\\sin(", "\\text{angle of plane}", ")", "\\over",
+ "\\sin(", "\\text{angle of cone slant}", ")}"
+ )
+ equation.set_color_by_tex("plane", YELLOW)
+ equation.set_color_by_tex("cone", BLUE)
+ equation.to_edge(LEFT)
+ self.play(FadeInFromDown(equation))
+
+
+class AskWhyAreTheyTheSame(TeacherStudentsScene):
+ def construct(self):
+ morty = self.teacher
+ self.student_says(
+ "Why on earth \\\\ are these the same?",
+ student_index=2,
+ target_mode="sassy",
+ bubble_kwargs={"direction": LEFT}
+ )
+ bubble = self.students[2].bubble
+ self.play(
+ morty.change, "awe",
+ self.get_student_changes("confused", "confused", "sassy")
+ )
+ self.look_at(self.screen)
+ self.wait(3)
+ self.play(morty.change, "thinking", self.screen)
+ self.change_student_modes("maybe", "erm", "confused")
+ self.look_at(self.screen)
+ self.wait(3)
+
+ baby_morty = BabyPiCreature()
+ baby_morty.match_style(morty)
+ baby_morty.to_corner(DL)
+
+ self.play(
+ FadeOutAndShift(bubble),
+ FadeOutAndShift(bubble.content),
+ LaggedStart(
+ FadeOutAndShift, self.students,
+ lambda m: (m, 3 * DOWN),
+ ),
+ ReplacementTransform(
+ morty, baby_morty,
+ path_arc=30 * DEGREES,
+ run_time=2,
+ )
+ )
+ self.pi_creatures = VGroup(baby_morty)
+ bubble = ThoughtBubble(height=6, width=7)
+ bubble.set_fill(DARK_GREY, 0.5)
+ bubble.pin_to(baby_morty)
+
+ egg = Circle(radius=0.4)
+ egg.stretch(0.75, 1)
+ egg.move_to(RIGHT)
+ egg.apply_function(
+ lambda p: np.array([
+ p[0], p[0] * p[1], p[2]
+ ])
+ )
+ egg.flip()
+ egg.scale_to_fit_width(3)
+ egg.set_stroke(RED, 5)
+ egg.move_to(bubble.get_bubble_center())
+
+ self.play(baby_morty.change, "confused", 2 * DOWN)
+ self.wait(2)
+ self.play(
+ baby_morty.change, "thinking",
+ LaggedStart(DrawBorderThenFill, bubble)
+ )
+ self.play(ShowCreation(egg))
+ self.wait(3)
+
+ bubble_group = VGroup(bubble, egg)
+ self.play(
+ ApplyMethod(
+ bubble_group.shift, FRAME_WIDTH * LEFT,
+ rate_func=running_start,
+ ),
+ baby_morty.change, "awe"
+ )
+ self.play(Blink(baby_morty))
+ self.wait()
+
+
+class TriangleOfEquivalences(Scene):
+ def construct(self):
+ title = Title("How do you prove this\\textinterrobang.")
+ self.add(title)
+ rects = VGroup(*[ScreenRectangle() for x in range(3)])
+ rects.scale_to_fit_height(2)
+ rects[:2].arrange_submobjects(RIGHT, buff=2)
+ rects[2].next_to(rects[:2], DOWN, buff=1.5)
+ rects.next_to(title, DOWN)
+
+ arrows = VGroup(*[
+ TexMobject("\\Leftrightarrow")
+ for x in range(3)
+ ])
+ arrows.scale(2)
+ arrows[0].move_to(rects[:2])
+ arrows[1].rotate(60 * DEGREES)
+ arrows[1].move_to(rects[1:])
+ arrows[2].rotate(-60 * DEGREES)
+ arrows[2].move_to(rects[::2])
+ arrows[1:].shift(0.5 * DOWN)
+
+ self.play(LaggedStart(
+ DrawBorderThenFill, arrows,
+ lag_ratio=0.7,
+ run_time=3,
+ ))
+ self.wait()
+ self.play(FadeOutAndShift(arrows[1:]))
+ self.wait()
class SliceCone(ExternallyAnimatedScene):
@@ -208,10 +806,110 @@ class IntroduceConeEllipseFocalSum(ExternallyAnimatedScene):
pass
+class ShowMeasurementBook(TeacherStudentsScene):
+ CONFIG = {"camera_config": {"background_opacity": 1}}
+
+ def construct(self):
+ measurement = ImageMobject("MeasurementCover")
+ measurement.scale_to_fit_height(3.5)
+ measurement.move_to(self.hold_up_spot, DOWN)
+
+ words = TextMobject("Highly recommended")
+ arrow = Vector(RIGHT, buff=WHITE)
+ arrow.next_to(measurement, LEFT)
+ words.next_to(arrow, LEFT)
+
+ self.play(
+ self.teacher.change, "raise_right_hand",
+ FadeInFromDown(measurement)
+ )
+ self.change_all_student_modes("hooray")
+ self.wait()
+ self.play(
+ GrowArrow(arrow),
+ FadeInAndShiftFromDirection(words, RIGHT),
+ self.get_student_changes(
+ "thinking", "happy", "pondering",
+ look_at_arg=arrow
+ )
+ )
+ self.wait(3)
+
+
class IntroduceSpheres(ExternallyAnimatedScene):
pass
+class TangencyAnimation(Scene):
+ def construct(self):
+ rings = VGroup(*[
+ Circle(color=YELLOW, stroke_width=3, radius=0.5)
+ for x in range(5)
+ ])
+ for ring in rings:
+ ring.save_state()
+ ring.scale(0)
+ ring.saved_state.set_stroke(width=0)
+
+ self.play(LaggedStart(
+ Restore, rings,
+ run_time=2,
+ lag_ratio=0.7
+ ))
+
+
+class TwoSpheresRotating(ExternallyAnimatedScene):
+ pass
+
+
+class TiltSlopeWithOnlySpheres(ExternallyAnimatedScene):
+ pass
+
+
+class TiltSlopeWithOnlySpheresSideView(ExternallyAnimatedScene):
+ pass
+
+
+class AskAboutWhyYouWouldAddSpheres(PiCreatureScene):
+ def construct(self):
+ randy = self.pi_creature
+ randy.flip()
+ randy.scale_to_fit_height(2)
+ randy.set_color(BLUE_C)
+ randy.to_edge(RIGHT)
+ randy.shift(2 * UP)
+ randy.look(UP)
+
+ graph_spot = VectorizedPoint()
+
+ why = TextMobject("...why?")
+ why.next_to(randy, UP)
+
+ bubble = ThoughtBubble(height=2, width=2)
+ bubble.pin_to(randy)
+
+ self.play(FadeInFromDown(randy))
+ self.play(
+ Animation(graph_spot),
+ randy.change, "maybe",
+ Write(why),
+ )
+ self.wait(3)
+ self.play(randy.change, "pondering")
+ self.play(
+ why.to_corner, DR,
+ why.set_fill, LIGHT_GREY, 0.5,
+ )
+ self.wait()
+ self.play(
+ ShowCreation(bubble),
+ randy.change, "thinking"
+ )
+ self.wait()
+ self.look_at(graph_spot)
+ self.wait(2)
+
+
class ShowTangencyPoints(ExternallyAnimatedScene):
pass
@@ -220,6 +918,28 @@ class ShowFocalLinesAsTangent(ExternallyAnimatedScene):
pass
+class UseDefiningFeatures(Scene):
+ def construct(self):
+ title = TextMobject("Problem-solving tip:")
+ title.scale(1.5)
+ title.to_edge(UP)
+ tip = TextMobject(
+ """
+ - Make sure you're using all the \\\\
+ \\phantom{-} defining features of the objects \\\\
+ \\phantom{-} involved.
+ """,
+ alignment=""
+ )
+ tip.next_to(title, DOWN, MED_LARGE_BUFF)
+ tip.shift(MED_SMALL_BUFF * RIGHT)
+ tip.set_color(YELLOW)
+
+ self.add(title)
+ self.play(Write(tip, lag_factor=5, run_time=4))
+ self.wait()
+
+
class RemindAboutTangencyToCone(ExternallyAnimatedScene):
pass
@@ -228,6 +948,60 @@ class ShowCircleToCircleLine(ExternallyAnimatedScene):
pass
+class ShowSegmentSplit(Scene):
+ CONFIG = {
+ "include_image": True,
+ }
+
+ def construct(self):
+ if self.include_image:
+ image = ImageMobject("ShowCircleToCircleLine")
+ image.scale_to_fit_height(FRAME_HEIGHT)
+ self.add(image)
+
+ brace1 = Brace(Line(ORIGIN, 1.05 * UP), LEFT)
+ brace2 = Brace(Line(1.7 * DOWN, ORIGIN), LEFT)
+ braces = VGroup(brace1, brace2)
+ braces.rotate(-14 * DEGREES)
+ braces.move_to(0.85 * UP + 1.7 * LEFT)
+
+ words = VGroup(
+ TextMobject("Top segment"),
+ TextMobject("Bottom segment")
+ )
+ for word, brace in zip(words, braces):
+ word.next_to(
+ brace.get_center(), LEFT,
+ buff=0.35
+ )
+ words[0].set_color(PINK)
+ words[1].set_color(GOLD)
+
+ for mob in it.chain(braces, words):
+ mob.add_to_back(mob.copy().set_stroke(BLACK, 5))
+
+ for brace in braces:
+ brace.save_state()
+ brace.set_stroke(width=0)
+ brace.scale(0)
+
+ self.play(
+ LaggedStart(
+ Restore, braces,
+ lag_ratio=0.7
+ ),
+ )
+ for word in words:
+ self.play(Write(word, run_time=1))
+ self.wait()
+
+
+class ShowSegmentSplitWithoutImage(ShowSegmentSplit):
+ CONFIG = {
+ "include_image": False,
+ }
+
+
class ShowCircleToCircleLineAtMultiplePoints(ExternallyAnimatedScene):
pass
@@ -236,14 +1010,112 @@ class ConjectureLineEquivalence(ExternallyAnimatedScene):
pass
-class LinesTangentToSphere(ExternallyAnimatedScene):
- pass
+class WriteConjecture(Scene):
+ CONFIG = {
+ "image_name": "ConjectureLineEquivalenceBigSphere",
+ "q_coords": 1.28 * UP + 0.15 * LEFT,
+ "circle_point_coords": 0.84 * RIGHT + 0.05 * DOWN,
+ "tangent_point_coords": 0.85 * UP + 1.75 * LEFT,
+ "plane_line_color": GOLD,
+ "text_scale_factor": 0.75,
+ "shift_plane_word_down": False,
+ "include_image": False,
+ }
+
+ def construct(self):
+ if self.include_image:
+ image = ImageMobject(self.image_name)
+ image.scale_to_fit_height(FRAME_HEIGHT)
+ self.add(image)
+
+ title = TextMobject("Conjecture:")
+ title.to_corner(UR)
+
+ cone_line = Line(self.q_coords, self.circle_point_coords)
+ plane_line = Line(self.q_coords, self.tangent_point_coords)
+ plane_line.set_color(self.plane_line_color)
+ lines = VGroup(cone_line, plane_line)
+
+ cone_line_words = TextMobject("Cone line")
+ plane_line_words = TextMobject("Plane line")
+ plane_line_words.set_color(self.plane_line_color)
+ words = VGroup(cone_line_words, plane_line_words)
+
+ for word in words:
+ word.add_to_back(word.copy().set_stroke(BLACK, 5))
+ word.in_equation = word.copy()
+
+ equation = VGroup(
+ TexMobject("||"),
+ words[0].in_equation,
+ TexMobject("||"),
+ TexMobject("="),
+ TexMobject("||"),
+ words[1].in_equation,
+ TexMobject("||"),
+ )
+ equation.arrange_submobjects(RIGHT, buff=SMALL_BUFF)
+ equation.scale(0.75)
+ equation.next_to(title, DOWN, MED_LARGE_BUFF)
+ equation.shift_onto_screen()
+ title.next_to(equation, UP)
+
+ for word, line in zip(words, lines):
+ word.scale(self.text_scale_factor)
+ word.next_to(ORIGIN, UP, SMALL_BUFF)
+ if self.shift_plane_word_down and (word is plane_line_words):
+ word.next_to(ORIGIN, DOWN, SMALL_BUFF)
+ angle = line.get_angle()
+ if abs(angle) > 90 * DEGREES:
+ angle += PI
+ word.rotate(angle, about_point=ORIGIN)
+ word.shift(line.get_center())
+
+ self.play(LaggedStart(
+ FadeInFromDown,
+ VGroup(title, equation),
+ lag_ratio=0.7
+ ))
+ self.wait()
+ for word, line in zip(words, lines):
+ self.play(ShowCreation(line))
+ self.play(WiggleOutThenIn(line))
+ self.play(ReplacementTransform(
+ word.in_equation.copy(), word
+ ))
+ self.wait()
+
+
+class WriteConjectureV2(WriteConjecture):
+ CONFIG = {
+ "image_name": "ConjectureLineEquivalenceSmallSphere",
+ "q_coords": 2.2 * LEFT + 1.3 * UP,
+ "circle_point_coords": 1.4 * LEFT + 2.25 * UP,
+ "tangent_point_coords": 0.95 * LEFT + 1.51 * UP,
+ "plane_line_color": PINK,
+ "text_scale_factor": 0.5,
+ "shift_plane_word_down": True,
+ "include_image": False,
+ }
+
+
+class ShowQ(Scene):
+ def construct(self):
+ mob = TexMobject("Q")
+ mob.scale(2)
+ mob.add_to_back(mob.copy().set_stroke(BLACK, 5))
+ self.play(FadeInFromDown(mob))
+ self.wait()
class ShowBigSphereTangentLines(ExternallyAnimatedScene):
pass
+class LinesTangentToSphere(ExternallyAnimatedScene):
+ pass
+
+
class ShowFocalSumEqualsCircleDistance(ExternallyAnimatedScene):
pass