def construct(self):
axes = Axes(x_axis_config={
"include_ticks": False
},
y_axis_config={
"include_ticks": False
},
number_line_config={
"color": self.axes_color
}).scale(0.9)
self.add(axes)
ellipse = Ellipse(width=self.width, height=self.height)
ellipse_x_axis = DashedLine(self.width / 2 * LEFT,
self.width / 2 * RIGHT,
color=BLACK)
ellipse_y_axis = DashedLine(self.height / 2 * UP,
self.height / 2 * DOWN,
color=BLACK)
elipticity_line = Line(self.width / 2 * LEFT,
self.height / 2 * UP,
color=BLUE)
elipticity_arc = Arc(0, math.atan(self.height / self.width)).shift(
self.width / 2 * LEFT)
ellipse_group = VGroup(ellipse, ellipse_x_axis, ellipse_y_axis,
elipticity_arc, elipticity_line)
ellipse_group.rotate(self.azimuth)
self.add(ellipse_group)
rightest = self.get_ellipse_rightest_point(self.width / 2,
self.height / 2,
self.azimuth)
highest = self.get_ellipse_highest_point(self.width / 2,
self.height / 2, self.azimuth)
vertical_line = Line(rightest * RIGHT,
rightest * RIGHT + highest * UP,
color=GREEN)
horizontal_line = Line(highest * UP,
highest * UP + rightest * RIGHT,
color=GREEN)
self.bring_to_back(vertical_line, horizontal_line)
azimuth_arc = Arc(0, self.azimuth)
self.add(azimuth_arc)
self.wait()
def construct(self):
number_line = NumberLine(x_min=-2, x_max=2)
text_1 = TextMobject("Theorem of") \
.next_to(number_line, DOWN)
text_2 = TextMobject("Beethoven") \
.next_to(number_line, DOWN)
dashed_line = DashedLine(
number_line.get_left(),
number_line.get_right(),
color=YELLOW,
).set_stroke(width=11)
self.add(number_line, text_1)
self.play(
LaggedStart(*[
ShowCreationThenDestruction(dashed_segment)
for dashed_segment in dashed_line
],
run_time=5),
AnimationGroup(Animation(Mobject(), run_time=2.1),
ReplacementTransform(text_1, text_2),
lag_ratio=1))
self.wait()
def generate_points(self):
dim, border = self.get_dimension_and_border()
axis = self.get_rotation_axis()
anchors = border.get_anchors()
num_pts = dim + 1
lpts, rpts = pts = [[
interpolate(sv, ev, alpha) for alpha in np.linspace(0, 1, num_pts)
][1:-1] for sv, ev in (anchors[0:2:1], anchors[-2:-4:-1])]
lines = VGroup(*[
DashedLine(lp, rp, **self.line_config)
for lp, rp in zip(lpts, rpts)
])
for angle in np.linspace(0, 2 * np.pi, 6, endpoint=False):
self.add(lines.copy().rotate_about_origin(angle, axis=axis))
for k in range(3):
self.add(DashedLine(anchors[k], anchors[k + 3],
**self.line_config))
# Hacky solution to the perspective problem in 3D
if self.mob_type == "ct":
height = self.ct_or_hexagon.get_height()
self.shift(height * (IN + LEFT + DOWN))
def construct(self):
number_line = NumberLine(x_min=-2, x_max=2)
text = TextMobject("Text") \
.next_to(number_line, DOWN)
dashed_line = DashedLine(
number_line.get_left(),
number_line.get_right(),
color=YELLOW,
).set_stroke(width=11)
self.add(number_line)
self.wait(0.3)
self.play(
LaggedStart(*[
ShowCreationThenDestruction(dashed_segment)
for dashed_segment in dashed_line
],
run_time=5),
AnimationGroup(Animation(Mobject(), run_time=2.1),
Write(text),
lag_ratio=1))
self.wait()
def __init__(self, mob, **kwargs):
VGroup.__init__(self, **kwargs)
if self.dashed == True:
medicion = DashedLine(
ORIGIN,
mob.get_length() * RIGHT,
dashed_segment_length=self.dashed_segment_length).set_color(
self.color)
else:
medicion = Line(ORIGIN, mob.get_length() * RIGHT)
medicion.set_stroke(None, self.stroke)
pre_medicion = Line(ORIGIN,
self.lateral * RIGHT).rotate(PI / 2).set_stroke(
None, self.stroke)
pos_medicion = pre_medicion.copy()
pre_medicion.move_to(medicion.get_start())
pos_medicion.move_to(medicion.get_end())
angulo = mob.get_angle()
matriz_rotacion = rotation_matrix(PI / 2, OUT)
vector_unitario = mob.get_unit_vector()
direccion = np.matmul(matriz_rotacion, vector_unitario)
self.direccion = direccion
self.add(medicion, pre_medicion, pos_medicion)
self.rotate(angulo)
self.move_to(mob)
if self.invert == True:
self.shift(-direccion * self.buff)
else:
self.shift(direccion * self.buff)
self.set_color(self.color)
self.tip_point_index = -np.argmin(self.get_all_points()[-1, :])
def scroll_through_patrons(self):
logo_box = Square(side_length=2.5)
logo_box.to_corner(DOWN + LEFT, buff=MED_LARGE_BUFF)
total_width = FRAME_X_RADIUS - logo_box.get_right()[0]
black_rect = Rectangle(
fill_color=BLACK,
fill_opacity=1,
stroke_width=3,
stroke_color=BLACK,
width=FRAME_WIDTH,
height=0.6 * FRAME_HEIGHT,
)
black_rect.to_edge(UP, buff=0)
line = DashedLine(FRAME_X_RADIUS * LEFT, FRAME_X_RADIUS * RIGHT)
line.move_to(ORIGIN)
thanks = TextMobject(self.thanks_words)
thanks.scale(0.9)
thanks.next_to(black_rect.get_bottom(), UP, SMALL_BUFF)
thanks.set_color(YELLOW)
underline = Line(LEFT, RIGHT)
underline.match_width(thanks)
underline.scale(1.1)
underline.next_to(thanks, DOWN, SMALL_BUFF)
thanks.add(underline)
changed_patron_names = map(
self.modify_patron_name,
self.specific_patrons,
)
patrons = VGroup(*map(
TextMobject,
changed_patron_names,
))
patrons.scale(self.patron_scale_val)
for patron in patrons:
if patron.get_width() > self.max_patron_width:
patron.set_width(self.max_patron_width)
columns = VGroup(*[
VGroup(*patrons[i::self.n_patron_columns])
for i in range(self.n_patron_columns)
])
for column in columns:
for n, name in enumerate(column):
name.shift(n * self.name_y_spacing * DOWN)
columns.arrange(
RIGHT, buff=LARGE_BUFF,
aligned_edge=UP,
)
max_width = FRAME_WIDTH - 1
if columns.get_width() > max_width:
columns.set_width(max_width)
underline.match_width(columns)
# thanks.to_edge(RIGHT, buff=MED_SMALL_BUFF)
columns.next_to(underline, DOWN, buff=2)
columns.generate_target()
columns.target.to_edge(DOWN, buff=2)
vect = columns.target.get_center() - columns.get_center()
distance = get_norm(vect)
wait_time = 20
always_shift(
columns,
direction=normalize(vect),
rate=(distance / wait_time)
)
self.add(columns, black_rect, line, thanks)
self.wait(wait_time)
def construct(self):
# Add title
title = self.title = TextMobject("Clicky Stuffs")
title.scale(1.5)
title.to_edge(UP, buff=MED_SMALL_BUFF)
pi_creatures = VGroup(Randolph(), Mortimer())
for pi, vect in zip(pi_creatures, [LEFT, RIGHT]):
pi.set_height(title.get_height())
pi.change_mode("thinking")
pi.look(DOWN)
pi.next_to(title, vect, buff=MED_LARGE_BUFF)
self.add(title, pi_creatures)
# Set the top of the screen
logo_box = Square(side_length=2.5)
logo_box.to_corner(DOWN + LEFT, buff=MED_LARGE_BUFF)
black_rect = Rectangle(
fill_color=BLACK,
fill_opacity=1,
stroke_width=3,
stroke_color=BLACK,
width=FRAME_WIDTH,
height=0.6 * FRAME_HEIGHT,
)
black_rect.to_edge(UP, buff=0)
line = DashedLine(FRAME_X_RADIUS * LEFT, FRAME_X_RADIUS * RIGHT)
line.move_to(ORIGIN)
# Add thanks
thanks = TextMobject(self.thanks_words)
thanks.scale(0.9)
thanks.next_to(black_rect.get_bottom(), UP, SMALL_BUFF)
thanks.set_color(YELLOW)
underline = Line(LEFT, RIGHT)
underline.match_width(thanks)
underline.scale(1.1)
underline.next_to(thanks, DOWN, SMALL_BUFF)
thanks.add(underline)
# Build name list
file_name = os.path.join(get_directories()["data"], "patrons.txt")
with open(file_name, "r") as fp:
names = [
self.modify_patron_name(name.strip())
for name in fp.readlines()
]
if self.randomize_order:
random.shuffle(names)
else:
names.sort()
name_labels = VGroup(*map(TextMobject, names))
name_labels.scale(self.patron_scale_val)
for label in name_labels:
if label.get_width() > self.max_patron_width:
label.set_width(self.max_patron_width)
columns = VGroup(*[
VGroup(*name_labels[i::self.n_patron_columns])
for i in range(self.n_patron_columns)
])
column_x_spacing = 0.5 + max([c.get_width() for c in columns])
for i, column in enumerate(columns):
for n, name in enumerate(column):
name.shift(n * self.name_y_spacing * DOWN)
name.align_to(ORIGIN, LEFT)
column.move_to(i * column_x_spacing * RIGHT, UL)
columns.center()
max_width = FRAME_WIDTH - 1
if columns.get_width() > max_width:
columns.set_width(max_width)
underline.match_width(columns)
columns.next_to(underline, DOWN, buff=3)
# Set movement
columns.generate_target()
distance = columns.get_height() + 2
wait_time = self.scroll_time
frame = self.camera.frame
frame_shift = ApplyMethod(
frame.shift,
distance * DOWN,
run_time=wait_time,
rate_func=linear,
)
blink_anims = []
blank_mob = Mobject()
for x in range(wait_time):
if random.random() < 0.25:
blink_anims.append(Blink(random.choice(pi_creatures)))
else:
blink_anims.append(Animation(blank_mob))
blinks = Succession(*blink_anims)
static_group = VGroup(black_rect, line, thanks, pi_creatures, title)
static_group.fix_in_frame()
self.add(columns, static_group)
self.play(frame_shift, blinks)
def get_refline(self):
if not hasattr(self, "refline"):
anchors = self.rhombus.get_anchors()
self.refline = DashedLine(anchors[0], anchors[2],
**self.refline_config)
return self.refline
def __init__(self, bond, **kwargs):
digest_config(self, kwargs)
start = bond.get_center() + (self.length / 2) * DOWN
end = start + self.length * UP
DashedLine.__init__(self, start=start, end=end)
def scroll_through_patrons(self):
logo_box = Square(side_length=2.5)
logo_box.to_corner(DOWN + LEFT, buff=MED_LARGE_BUFF)
total_width = FRAME_X_RADIUS - logo_box.get_right()[0]
black_rect = Rectangle(
fill_color=BLACK,
fill_opacity=1,
stroke_width=3,
stroke_color=BLACK,
width=FRAME_WIDTH,
height=0.6 * FRAME_HEIGHT,
)
black_rect.to_edge(UP, buff=0)
line = DashedLine(FRAME_X_RADIUS * LEFT, FRAME_X_RADIUS * RIGHT)
line.move_to(ORIGIN)
thanks = TextMobject(self.thanks_words)
thanks.scale(0.9)
thanks.next_to(black_rect.get_bottom(), UP, SMALL_BUFF)
thanks.set_color(YELLOW)
underline = Line(LEFT, RIGHT)
underline.match_width(thanks)
underline.scale(1.1)
underline.next_to(thanks, DOWN, SMALL_BUFF)
thanks.add(underline)
changed_patron_names = map(
self.modify_patron_name,
self.specific_patrons,
)
patrons = VGroup(*map(
TextMobject,
changed_patron_names,
))
patrons.scale(self.patron_scale_val)
for patron in patrons:
if patron.get_width() > self.max_patron_width:
patron.set_width(self.max_patron_width)
columns = VGroup(*[
VGroup(*patrons[i::self.n_patron_columns])
for i in range(self.n_patron_columns)
])
for column in columns:
for n, name in enumerate(column):
name.shift(n * self.name_y_spacing * DOWN)
columns.arrange(
RIGHT, buff=LARGE_BUFF,
aligned_edge=UP,
)
if columns.get_width() > self.max_patron_width:
columns.set_width(total_width - 1)
thanks.to_edge(RIGHT, buff=MED_SMALL_BUFF)
columns.next_to(underline, DOWN, buff=2)
columns.generate_target()
columns.target.to_edge(DOWN, buff=2)
vect = columns.target.get_center() - columns.get_center()
distance = get_norm(vect)
wait_time = 20
always_shift(
columns,
direction=normalize(vect),
rate=(distance / wait_time)
)
self.add(columns, black_rect, line, thanks)
self.wait(wait_time)
