def construct(self):
text = TextMobject([
"PHC", "_n", "(", "x", ")$",
" has a limit point ", "as $n \\to \\infty$",
"\\\\ for all $x$"
])
parts = text.split()
parts[-1].next_to(Mobject(*parts[:-1]), DOWN)
parts[-1].highlight(BLUE)
parts[3].highlight(BLUE)
parts[1].highlight()
parts[-2].highlight()
text.to_edge(UP)
curve = UnitInterval()
curve.sort_points(lambda p : p[0])
vals = np.arange(0.1, 1, 0.1)
dots = Mobject(*[
Dot(curve.number_to_point(val))
for val in vals
])
curve.add_numbers(0, 1)
starter_dots = dots.copy().ingest_sub_mobjects()
starter_dots.shift(2*UP)
self.add(curve, text)
self.dither()
self.play(DelayByOrder(ApplyMethod(starter_dots.shift, 2*DOWN)))
self.dither()
self.remove(starter_dots)
self.add(dots)
for num in range(1, 10):
new_curve = HilbertCurve(order = num)
new_curve.scale(0.8)
new_dots = Mobject(*[
Dot(new_curve.points[int(val*new_curve.get_num_points())])
for val in vals
])
self.play(
Transform(curve, new_curve),
Transform(dots, new_dots),
)
def construct(self):
val = 0.3
text = TextMobject([
"PHC", "$_n", "(",
"%3.1f" % val, ")$", " has a ", "limit point ",
"as $n \\to \\infty$"
])
func_parts = text.copy().split()[:5]
Mobject(*func_parts).center().to_edge(UP)
num_str, val_str = func_parts[1], func_parts[3]
curve = UnitInterval()
curve.sort_points(lambda p: p[0])
dot = Dot().shift(curve.number_to_point(val))
arrow = Arrow(val_str, dot, buff=0.1)
curve.add_numbers(0, 1)
self.play(ShowCreation(curve))
self.play(ShimmerIn(val_str), ShowCreation(arrow), ShowCreation(dot))
self.dither()
self.play(FadeOut(arrow), *[FadeIn(func_parts[i]) for i in 0, 1, 2, 4])
for num in range(2, 9):
new_curve = HilbertCurve(order=num)
new_curve.scale(0.8)
new_dot = Dot(new_curve.points[int(val *
new_curve.get_num_points())])
new_num_str = TexMobject(str(num)).replace(num_str)
self.play(Transform(curve, new_curve), Transform(dot, new_dot),
Transform(num_str, new_num_str))
self.dither()
text.to_edge(UP)
text_parts = text.split()
for index in 1, -1:
text_parts[index].highlight()
starters = Mobject(*func_parts + [
Point(mob.get_center(), stroke_width=1) for mob in text_parts[5:]
])
self.play(Transform(starters, text))
arrow = Arrow(text_parts[-2].get_bottom(), dot, buff=0.1)
self.play(ShowCreation(arrow))
self.dither()
def increase_order(self):
mini_curves = [
self.curve.copy().scale(0.5).shift(1.5 * vect)
for vect in [LEFT + DOWN, LEFT + UP, RIGHT + UP, RIGHT + DOWN]
]
self.remove(self.curve)
self.play(Transform(self.curve.copy(), mini_curves[0]))
self.play(
*[GrowFromCenter(mini_curve) for mini_curve in mini_curves[1:]])
self.wait()
self.clear()
self.add(*mini_curves)
self.play(*[
ApplyMethod(curve.rotate_in_place, np.pi, axis)
for curve, axis in [(mini_curves[0],
UP + RIGHT), (mini_curves[3], UP + LEFT)]
])
self.curve = HilbertCurve(order=self.curve.order + 1)
self.play(ShowCreation(self.curve, run_time=2))
self.remove(*mini_curves)
self.wait()
def construct(self, order):
start_color, end_color = RED, GREEN
curve = HilbertCurve(order=order)
line = Line(5 * LEFT, 5 * RIGHT)
for mob in curve, line:
mob.set_color_by_gradient(start_color, end_color)
freq_line = get_freq_line()
freq_line.replace(line, stretch=True)
unit = 6. / (2**order) #sidelength of pixel
up = unit * UP
right = unit * RIGHT
lower_left = 3 * (LEFT + DOWN)
squares = Mobject(*[
Square(side_length=unit, color=WHITE).shift(x * right + y * up)
for x, y in it.product(range(2**order), range(2**order))
])
squares.center()
targets = Mobject()
for square in squares.submobjects:
center = square.get_center()
distances = np.apply_along_axis(
lambda p: np.linalg.norm(p - center), 1, curve.points)
index_along_curve = np.argmin(distances)
fraction_along_curve = index_along_curve / float(
curve.get_num_points())
target = square.copy().center().scale(0.8 / (2**order))
line_index = int(fraction_along_curve * line.get_num_points())
target.shift(line.points[line_index])
targets.add(target)
self.add(squares)
self.play(ShowCreation(curve, run_time=5, rate_func=None))
self.wait()
self.play(Transform(curve, line),
Transform(squares, targets),
run_time=3)
self.wait()
self.play(ShowCreation(freq_line))
self.wait()
def construct(self):
val = 0.7
text = TexMobject([
"\\text{HC}(", "x", ")", "=\\lim_{n \\to \\infty}\\text{PHC}_n(",
"x", ")"
])
text.to_edge(UP)
x1 = text.split()[1]
x2 = text.split()[-2]
x2.set_color(BLUE)
explanation = TextMobject("Actual Hilbert curve function")
exp_arrow = Arrow(explanation, text.split()[0])
curve = UnitInterval()
dot = Dot(curve.number_to_point(val))
x_arrow = Arrow(x1.get_bottom(), dot, buff=0)
curve.sort_points(lambda p: p[0])
curve.add_numbers(0, 1)
self.add(*text.split()[:3])
self.play(ShimmerIn(explanation), ShowCreation(exp_arrow))
self.wait()
self.remove(explanation, exp_arrow)
self.play(ShowCreation(curve))
self.play(ApplyMethod(x1.set_color, BLUE), ShowCreation(x_arrow),
ShowCreation(dot))
self.wait()
self.remove(x_arrow)
limit = Mobject(*text.split()[3:]).ingest_submobjects()
limit.stroke_width = 1
self.play(ShimmerIn(limit))
for num in range(1, 9):
new_curve = HilbertCurve(order=num)
new_curve.scale(0.8)
new_dot = Dot(new_curve.points[int(val *
new_curve.get_num_points())])
self.play(
Transform(curve, new_curve),
Transform(dot, new_dot),
)
def construct(self):
curve = HilbertCurve(order=6)
curve.set_color(WHITE)
colored_curve = curve.copy()
colored_curve.thin_out(3)
lion = ImageMobject("lion", invert=False)
lion.replace(curve, stretch=True)
sparce_lion = lion.copy()
sparce_lion.thin_out(100)
distance_matrix = cdist(colored_curve.points, sparce_lion.points)
closest_point_indices = np.apply_along_axis(np.argmin, 1,
distance_matrix)
colored_curve.rgbas = sparce_lion.rgbas[closest_point_indices]
line = Line(5 * LEFT, 5 * RIGHT)
Mobject.align_data(line, colored_curve)
line.rgbas = colored_curve.rgbas
self.add(lion)
self.play(ShowCreation(curve, run_time=3))
self.play(FadeOut(lion), Transform(curve, colored_curve), run_time=3)
self.wait()
self.play(Transform(curve, line, run_time=5))
self.wait()
def construct(self):
time_line = get_time_line()
time_line.shift(-time_line.number_to_point(1900))
hilbert_curve = HilbertCurve(order=3)
peano_curve = PeanoCurve(order=2)
for curve in hilbert_curve, peano_curve:
curve.scale(0.5)
hilbert_curve.to_corner(DOWN + RIGHT)
peano_curve.to_corner(UP + LEFT)
squares = Mobject(*[
Square(side_length=3, color=WHITE).replace(curve)
for curve in (hilbert_curve, peano_curve)
])
self.add(time_line)
self.wait()
for year, curve, vect, text in [
(1890, peano_curve, UP, "Peano Curve"),
(1891, hilbert_curve, DOWN, "Hilbert Curve"),
]:
point = time_line.number_to_point(year)
point[1] = 0.2
arrow = Arrow(point + 2 * vect, point, buff=0.1)
arrow.set_color_by_gradient(curve.start_color, curve.end_color)
year_mob = TexMobject(str(year))
year_mob.next_to(arrow, vect)
words = TextMobject(text)
words.next_to(year_mob, vect)
self.play(ShowCreation(arrow), ShimmerIn(year_mob),
ShimmerIn(words))
self.play(ShowCreation(curve))
self.wait()
self.play(ShowCreation(squares))
self.wait()
self.play(
ApplyMethod(Mobject(*self.mobjects).shift, 20 * (DOWN + RIGHT)))
def construct(self):
self.curve = HilbertCurve(order = 1)
self.add(self.curve)
self.wait()
while self.curve.order < 8:
self.increase_order()
