def circle_to_mobject(self, circle_element):
x, y, r = [
float(circle_element.getAttribute(key))
if circle_element.hasAttribute(key) else 0.0
for key in ("cx", "cy", "r")
]
return Circle(radius=r).shift(x * RIGHT + y * DOWN)
def ellipse_to_mobject(self, circle_element):
x, y, rx, ry = [
float(circle_element.getAttribute(key))
if circle_element.hasAttribute(key) else 0.0
for key in ("cx", "cy", "rx", "ry")
]
return Circle().scale(rx * RIGHT + ry * UP).shift(x * RIGHT + y * DOWN)
def add_pupil(self):
self.pupil = Circle(radius=self.pupil_radius,
fill_color=BLACK,
fill_opacity=1,
stroke_width=0,
sheen=0.0)
self.add(self.pupil)
def construct(self):
formula = TexMobject(*([
"{%d \\over %d} \\cdot" % (wallis_numer(n), wallis_denom(n))
for n in range(1, self.n_terms + 1)
] + ["\\cdots"]))
result = TexMobject("=", "{\\pi \\over 2}")
result.scale(2)
pi = result[-1][0]
pi.set_color(YELLOW)
circle = Circle(color=YELLOW)
circle.surround(pi)
question = TexMobject("?", color=YELLOW)
question.scale(2).next_to(circle, RIGHT, buff=0.4)
result_group = VGroup(result, circle, question)
result_group.next_to(formula, DOWN)
group = VGroup(formula, result_group)
group.center().set_width(10)
bg_rect = BackgroundRectangle(group, fill_opacity=0.5, buff=0.2)
random_walks = VGroup(*[
RandomWalk1DArrow(random_walk_string(30), step_size=0.5)
for k in range(self.n_walks)
])
for k, walk in enumerate(random_walks):
walk.shift(random.randrange(-5, 5) * 2 * walk.step_size * UP)
random_walks.center()
text = TextMobject(self.part).scale(3).set_color(YELLOW)
text.to_corner(RIGHT + DOWN)
self.add(random_walks)
self.add(FullScreenFadeRectangle())
self.add(bg_rect, group, text)
def generate_mobject(self, dic, labels):
# generate mobject attributes from component attributes
# update number of labels for scaling
num_labels = len(self.labels)
for key in labels:
if key not in self.labels:
num_labels += 1
if key in self.labels and labels[key] is None:
num_labels -= 1
if "scale_factor" not in dic:
if hasattr(self, "mobject") and \
hasattr(self.mobject, "scale_factor"):
dic["scale_factor"] = self.mobject.scale_factor
else:
print("Attempted to initialize Node without scale_factor")
breakpoint(context=7)
if "radius" in dic:
pass
elif num_labels > 0:
dic["radius"] = LABELED_NODE_RADIUS * dic["scale_factor"]
elif num_labels == 0:
dic["radius"] = UNLABELED_NODE_RADIUS * dic["scale_factor"]
else:
dic["radius"] = self.mobject.radius
if "stroke_width" not in dic:
if hasattr(self, "mobject") and \
hasattr(self.mobject, "stroke_width"):
dic["stroke_width"] = self.mobject.stroke_width
else:
print("Attempted to initialize Node without stroke_width")
breakpoint(context=7)
if "color" not in dic:
if hasattr(self, "mobject") and \
hasattr(self.mobject, "color"):
dic["color"] = self.mobject.color
else:
print("Attempted to initialize Node without color")
breakpoint(context=7)
mobject_class = dic.get("mobject_class", None)
if mobject_class is None:
new_mob = Circle(**dic)
else:
new_mob = mobject_class(**dic)
# the component is first initialized without a mobject attr
if not hasattr(self, "mobject"):
new_mob.move_to(self.key)
else:
new_mob.move_to(self.mobject.get_center())
return new_mob
def __init__(self, **kwargs):
SVGMobject.__init__(self, **kwargs)
circle = Circle(
stroke_width=3,
stroke_color=GREEN,
fill_opacity=1,
fill_color=BLUE_C,
)
circle.replace(self)
self.add_to_back(circle)
def __init__(self, **kwargs):
circle = Circle()
ticks = []
for x in range(12):
alpha = x / 12.
point = complex_to_R3(np.exp(2 * np.pi * alpha * complex(0, 1)))
length = 0.2 if x % 3 == 0 else 0.1
ticks.append(Line(point, (1 - length) * point))
self.hour_hand = Line(ORIGIN, 0.3 * UP)
self.minute_hand = Line(ORIGIN, 0.6 * UP)
# for hand in self.hour_hand, self.minute_hand:
# #Balance out where the center is
# hand.add(VectorizedPoint(-hand.get_end()))
VGroup.__init__(self, circle, self.hour_hand, self.minute_hand, *ticks)
def __init__(self, focal_point, **kwargs):
digest_config(self, kwargs)
circles = VGroup()
for x in range(self.n_circles):
circle = Circle(
radius=self.big_radius,
stroke_color=BLACK,
stroke_width=0,
)
circle.move_to(focal_point)
circle.save_state()
circle.set_width(self.small_radius * 2)
circle.set_stroke(self.color, self.start_stroke_width)
circles.add(circle)
LaggedStart.__init__(self, ApplyMethod, circles, lambda c:
(c.restore, ), **kwargs)
def increment(self, run_time_per_anim=1):
moving_dot = Dot(
self.counting_dot_starting_position,
radius=self.count_dot_starting_radius,
color=self.digit_place_colors[0],
)
moving_dot.generate_target()
moving_dot.set_fill(opacity=0)
kwargs = {
"run_time": run_time_per_anim
}
continue_rolling_over = True
first_move = True
place = 0
while continue_rolling_over:
added_anims = []
if first_move:
added_anims += self.get_digit_increment_animations()
first_move = False
moving_dot.target.replace(
self.dot_template_iterators[place].next()
)
self.play(MoveToTarget(moving_dot), *added_anims, **kwargs)
self.curr_configurations[place].add(moving_dot)
if len(self.curr_configurations[place].split()) == self.get_place_max(place):
full_configuration = self.curr_configurations[place]
self.curr_configurations[place] = VGroup()
place += 1
center = full_configuration.get_center_of_mass()
radius = 0.6 * max(
full_configuration.get_width(),
full_configuration.get_height(),
)
circle = Circle(
radius=radius,
stroke_width=0,
fill_color=self.digit_place_colors[place],
fill_opacity=0.5,
)
circle.move_to(center)
moving_dot = VGroup(circle, full_configuration)
moving_dot.generate_target()
moving_dot[0].set_fill(opacity=0)
else:
continue_rolling_over = False
def animate_product(self, left, right, result):
l_matrix = left.get_mob_matrix()
r_matrix = right.get_mob_matrix()
result_matrix = result.get_mob_matrix()
circle = Circle(radius=l_matrix[0][0].get_height(), color=GREEN)
circles = VGroup(*[
entry.get_point_mobject()
for entry in (l_matrix[0][0], r_matrix[0][0])
])
(m, k), n = l_matrix.shape, r_matrix.shape[1]
for mob in result_matrix.flatten():
mob.set_color(BLACK)
lagging_anims = []
for a in range(m):
for b in range(n):
for c in range(k):
l_matrix[a][c].set_color(YELLOW)
r_matrix[c][b].set_color(YELLOW)
for c in range(k):
start_parts = VGroup(l_matrix[a][c].copy(),
r_matrix[c][b].copy())
result_entry = result_matrix[a][b].split()[c]
new_circles = VGroup(*[
circle.copy().shift(part.get_center())
for part in start_parts.split()
])
self.play(Transform(circles, new_circles))
self.play(
Transform(
start_parts,
result_entry.copy().set_color(YELLOW),
path_arc=-np.pi / 2,
submobject_mode="all_at_once",
), *lagging_anims)
result_entry.set_color(YELLOW)
self.remove(start_parts)
lagging_anims = [
ApplyMethod(result_entry.set_color, WHITE)
]
for c in range(k):
l_matrix[a][c].set_color(WHITE)
r_matrix[c][b].set_color(WHITE)
self.play(FadeOut(circles), *lagging_anims)
self.wait()
def construct(self):
# Setup
axes_group = self.axes_group
title_pq = self.title_pq
walk_p = self.walk_p
parts_p = self.parts_p
r_arrow = self.r_arrow
self.add(axes_group, title_pq, walk_p, r_arrow)
walk_p_copy = walk_p.copy()
# P_4 -> Q_4
steps_pq = VGroup(*[
TextMobject(text) for text in [
"1. 第一步是沿着正方向走的", "2. 找到第一次到达最大值的时刻", "3. 在这个时刻上进行分割",
"4. 将第一段水平翻转", "5. 拼接两个片段"
]
])
for step in steps_pq:
step.set_color(YELLOW)
step.add_background_rectangle()
step1_pq, step2_pq, step3_pq, step4_pq, step5_pq = steps_pq
# 1. Check the first step of the walk
step1_circle = Circle(color=YELLOW)
first_arrow = walk_p.get_arrow_by_number(0)
step1_circle.surround(first_arrow)
step1_pq.next_to(step1_circle, RIGHT + DOWN)
self.play(ShowCreation(step1_circle), Write(step1_pq), run_time=1)
self.wait(1.5)
self.play(FadeOut(step1_circle), FadeOut(step1_pq))
# 2. Find the first time it reaches the maximum
peak = walk_p.get_arrow_end_point(3)
horiz_line = DashedLine(2.5 * LEFT, 2.5 * RIGHT, color=YELLOW)
horiz_line.move_to(peak)
dot = Dot(color=YELLOW)
dot.move_to(peak)
step2_pq.next_to(horiz_line, UP)
self.play(ShowCreation(horiz_line),
DrawBorderThenFill(dot),
Write(step2_pq),
run_time=1)
self.wait(1.5)
self.play(FadeOut(horiz_line), FadeOut(step2_pq))
# 3. Split
vert_line = DashedLine(2.5 * UP, 2.5 * DOWN, color=YELLOW)
vert_line.move_to(peak)
step3_pq.next_to(vert_line, DOWN)
left_part_p, right_part_p = parts_p
self.play(ShowCreation(vert_line), Write(step3_pq), run_time=1)
self.play(
FadeOut(dot),
left_part_p.shift,
0.5 * DOWN + 0.5 * LEFT,
right_part_p.shift,
DOWN + 0.5 * RIGHT,
)
self.wait(1.5)
self.play(FadeOut(vert_line), FadeOut(step3_pq))
# 4. Flip the first segment horizontally
flip_axis = DashedLine(2 * UP, 2 * DOWN, color=GREY)
flip_axis.move_to(left_part_p)
step4_pq.next_to(flip_axis, DOWN)
self.play(
ShowCreation(flip_axis),
Write(step4_pq),
run_time=1,
)
self.play(
left_part_p.flip,
Animation(flip_axis),
)
self.wait(1.5)
self.play(FadeOut(step4_pq), FadeOut(flip_axis))
# 5. Put the pieces together
step5_pq.move_to(dot)
flip_arrow_anims = walk_p.get_flip_arrows_animation(3, color=GREEN)
self.play(Write(step5_pq), run_time=1)
self.wait(0.5)
self.play(flip_arrow_anims, right_part_p.set_color, GREEN)
self.wait(0.5)
self.play(
left_part_p.shift,
1.5 * DOWN + 0.5 * RIGHT,
right_part_p.shift,
3 * DOWN + 0.5 * LEFT,
Animation(step5_pq),
)
self.wait(0.5)
self.play(FadeOut(step5_pq))
self.wait(1.5)
# Now Reset
self.play(FadeOut(walk_p))
self.play(FadeIn(walk_p_copy))
self.wait()
def get_seed_shape(self):
return Circle()
def __init__(self, mobject, **kwargs):
digest_config(self, kwargs)
circle = Circle(color=self.color, **kwargs)
circle.surround(mobject)
Indicate.__init__(self, circle, **kwargs)