Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Factor out holomorphic project into two separate videos

Grant Sanderson4c762aeb79c5
diff --git a/active_projects/holomorphic.py b/active_projects/conformal.py
similarity index 63%
rename from active_projects/holomorphic.py
rename to active_projects/conformal.py
index 5227985d8..a769898d0 100644
--- a/active_projects/holomorphic.py
+++ b/active_projects/conformal.py
@@ -1,174 +1,6 @@
from big_ol_pile_of_manim_imports import *
-# Helper functions
-def get_flow_start_points(x_min=-8, x_max=8,
- y_min=-5, y_max=5,
- delta_x=0.5, delta_y=0.5,
- n_repeats=1,
- noise_factor=0.01
- ):
- return np.array([
- x * RIGHT + y * UP + noise_factor * np.random.random(3)
- for n in xrange(n_repeats)
- for x in np.arange(x_min, x_max + delta_x, delta_x)
- for y in np.arange(y_min, y_max + delta_y, delta_y)
- ])
-
-
-def joukowsky_map(z):
- return z + fdiv(1, z)
-
-
-def inverse_joukowsky_map(w):
- u = 1 if w.real <= 0 else -1
- return (w + u * np.sqrt(w**2 - 4)) / 2
-
-
-def derivative(func, dt=1e-7):
- return lambda z: (func(z + dt) - func(z)) / dt
-
-
-def cylinder_flow_vector_field(point, R=1, U=1):
- z = R3_to_complex(point)
- return complex_to_R3(1.0 / derivative(joukowsky_map)(z))
-
-
-# Continual animations
-
-class VectorFieldFlow(ContinualAnimation):
- CONFIG = {
- "mode": None,
- }
-
- def __init__(self, mobject, func, **kwargs):
- """
- Func should take in a vector in R3, and output a vector in R3
- """
- self.func = func
- ContinualAnimation.__init__(self, mobject, **kwargs)
-
- def update_mobject(self, dt):
- self.apply_nudge(dt)
-
- def apply_nudge(self):
- self.mobject.shift(self.func(self.mobject.get_center()) * dt)
-
-
-class VectorFieldSubmobjectFlow(VectorFieldFlow):
- def apply_nudge(self, dt):
- for submob in self.mobject:
- submob.shift(self.func(submob.get_center()) * dt)
-
-
-class VectorFieldPointFlow(VectorFieldFlow):
- def apply_nudge(self, dt):
- self.mobject.apply_function(
- lambda p: p + self.func(p) * dt
- )
-
-
-class StreamLines(VGroup):
- CONFIG = {
- "start_points_generator": get_flow_start_points,
- "dt": 0.05,
- "virtual_time": 20,
- "n_anchors_per_line": 30,
- "stroke_width": 1,
- "stroke_color": WHITE,
- }
-
- def __init__(self, func, **kwargs):
- VGroup.__init__(self, **kwargs)
- self.func = func
- dt = self.dt
-
- start_points = self.start_points_generator()
- for point in start_points:
- points = [point]
- for t in np.arange(0, self.virtual_time, dt):
- last_point = points[-1]
- points.append(last_point + dt * func(last_point))
- line = VMobject()
- line.set_points_smoothly(
- points[::(len(points) / self.n_anchors_per_line)]
- )
- self.add(line)
-
- self.set_stroke(self.stroke_color, self.stroke_width)
-
-
-class StreamLineAnimation(ContinualAnimation):
- CONFIG = {
- "lag_range": 4,
- "line_anim_class": ShowPassingFlash,
- "line_anim_config": {
- "run_time": 4,
- "rate_func": None,
- "time_width": 0.4,
- },
- }
-
- def __init__(self, stream_lines, **kwargs):
- digest_config(self, kwargs)
- self.stream_lines = stream_lines
- for line in stream_lines:
- line.anim = self.line_anim_class(line, **self.line_anim_config)
- line.time = -self.lag_range * random.random()
- ContinualAnimation.__init__(self, stream_lines, **kwargs)
-
- def update_mobject(self, dt):
- stream_lines = self.stream_lines
- for line in stream_lines:
- line.time += dt
- adjusted_time = max(line.time, 0) % line.anim.run_time
- line.anim.update(adjusted_time / line.anim.run_time)
-
-# Scenes
-
-
-class TestVectorField(Scene):
- CONFIG = {
- "func": cylinder_flow_vector_field,
- }
-
- def construct(self):
- plane = ComplexPlane()
- self.add(plane)
-
- circle = Circle(stroke_color=YELLOW)
- circle.set_fill(BLACK, 1)
- self.add_foreground_mobject(circle)
-
- lines = StreamLines(
- self.func,
- start_points_generator=lambda: get_flow_start_points(
- x_min=-8, x_max=-7, y_min=-2, y_max=2,
- delta_x=0.5, delta_y=0.2,
- n_repeats=4,
- noise_factor=0.2,
- ),
- )
- self.add(lines)
- return
- stream_line_animation = StreamLineAnimation(lines)
- self.add(stream_line_animation)
- self.wait(8)
- self.play(VFadeOut(lines))
- self.remove(stream_line_animation)
- self.wait()
-
- # dots = VGroup(*[
- # Dot().move_to(start_point)
- # for start_point in get_flow_start_points()
- # ])
- # dots.set_color_by_gradient(YELLOW, RED)
- # self.add(dots)
-
- # self.add(VectorFieldSubmobjectFlow(dots, self.func))
- # self.wait(5)
-
-
class ComplexAnalysisOverlay(Scene):
def construct(self):
words = TextMobject("Complex analysis")
diff --git a/active_projects/div_curl.py b/active_projects/div_curl.py
new file mode 100644
index 000000000..67eda49fb
--- /dev/null
+++ b/active_projects/div_curl.py
@@ -0,0 +1,353 @@
+from big_ol_pile_of_manim_imports import *
+
+
+DEFAULT_SCALAR_FIELD_COLORS = [BLUE_E, GREEN, WHITE, ORANGE, RED]
+
+
+# Helper functions
+def get_flow_start_points(x_min=-8, x_max=8,
+ y_min=-5, y_max=5,
+ delta_x=0.5, delta_y=0.5,
+ n_repeats=1,
+ noise_factor=0.01
+ ):
+ return np.array([
+ x * RIGHT + y * UP + noise_factor * np.random.random(3)
+ for n in xrange(n_repeats)
+ for x in np.arange(x_min, x_max + delta_x, delta_x)
+ for y in np.arange(y_min, y_max + delta_y, delta_y)
+ ])
+
+
+def joukowsky_map(z):
+ return z + fdiv(1, z)
+
+
+def inverse_joukowsky_map(w):
+ u = 1 if w.real <= 0 else -1
+ return (w + u * np.sqrt(w**2 - 4)) / 2
+
+
+def derivative(func, dt=1e-7):
+ return lambda z: (func(z + dt) - func(z)) / dt
+
+
+def cylinder_flow_vector_field(point, R=1, U=1):
+ z = R3_to_complex(point)
+ # return complex_to_R3(1.0 / derivative(joukowsky_map)(z))
+ return complex_to_R3(derivative(joukowsky_map)(z).conjugate())
+
+
+def cylinder_flow_magnitude_field(point):
+ return np.linalg.norm(cylinder_flow_vector_field(point))
+
+
+def get_colored_background_image(scalar_field_func,
+ number_to_rgb_func,
+ pixel_height=DEFAULT_PIXEL_HEIGHT,
+ pixel_width=DEFAULT_PIXEL_WIDTH,
+ ):
+ ph = pixel_height
+ pw = pixel_width
+ fw = FRAME_WIDTH
+ fh = FRAME_HEIGHT
+ points_array = np.zeros((ph, pw, 3))
+ x_array = np.linspace(-fw / 2, fw / 2, ph).repeat(pw).reshape((ph, pw))
+ y_array = np.linspace(fh / 2, -fh / 2, pw).repeat(ph).reshape((pw, ph)).T
+ points_array[:, :, 0] = x_array
+ points_array[:, :, 1] = y_array
+ scalars = np.apply_along_axis(scalar_field_func, 2, points_array)
+ rgb_array = number_to_rgb_func(scalars.flatten()).reshape((ph, pw, 3))
+ return Image.fromarray((rgb_array * 255).astype('uint8'))
+
+
+def get_rgb_gradient_function(min_value=0, max_value=1, colors=[BLUE, RED]):
+ rgbs = np.array(map(color_to_rgb, colors))
+
+ def func(values):
+ alphas = inverse_interpolate(min_value, max_value, values)
+ alphas = np.clip(alphas, 0, 1)
+ alphas = 1 - alphas # Why?
+ scaled_alphas = alphas * (len(rgbs) - 1)
+ indices = scaled_alphas.astype(int)
+ next_indices = np.clip(indices + 1, 0, len(rgbs) - 1)
+ inter_alphas = scaled_alphas % 1
+ inter_alphas = inter_alphas.repeat(3).reshape((len(indices), 3))
+ result = interpolate(rgbs[indices], rgbs[next_indices], inter_alphas)
+ return result
+
+ return func
+
+
+def get_color_field_image_file(scalar_func,
+ min_value=0, max_value=2,
+ colors=DEFAULT_SCALAR_FIELD_COLORS
+ ):
+ # try_hash
+ np.random.seed(0)
+ sample_inputs = 5 * np.random.random(size=(10, 3)) - 10
+ sample_outputs = np.apply_along_axis(scalar_func, 1, sample_inputs)
+ func_hash = hash(
+ str(min_value) + str(max_value) + str(colors) + str(sample_outputs)
+ )
+ file_name = "%d.png" % func_hash
+ full_path = os.path.join(RASTER_IMAGE_DIR, file_name)
+ if not os.path.exists(full_path):
+ print "Rendering color field image " + str(func_hash)
+ rgb_gradient_func = get_rgb_gradient_function(
+ min_value=min_value,
+ max_value=max_value,
+ colors=colors
+ )
+ image = get_colored_background_image(scalar_func, rgb_gradient_func)
+ image.save(full_path)
+ return full_path
+
+
+# Continual animations
+
+
+class VectorFieldFlow(ContinualAnimation):
+ CONFIG = {
+ "mode": None,
+ }
+
+ def __init__(self, mobject, func, **kwargs):
+ """
+ Func should take in a vector in R3, and output a vector in R3
+ """
+ self.func = func
+ ContinualAnimation.__init__(self, mobject, **kwargs)
+
+ def update_mobject(self, dt):
+ self.apply_nudge(dt)
+
+ def apply_nudge(self):
+ self.mobject.shift(self.func(self.mobject.get_center()) * dt)
+
+
+class VectorFieldSubmobjectFlow(VectorFieldFlow):
+ def apply_nudge(self, dt):
+ for submob in self.mobject:
+ submob.shift(self.func(submob.get_center()) * dt)
+
+
+class VectorFieldPointFlow(VectorFieldFlow):
+ def apply_nudge(self, dt):
+ self.mobject.apply_function(
+ lambda p: p + self.func(p) * dt
+ )
+
+
+class StreamLines(VGroup):
+ CONFIG = {
+ "start_points_generator": get_flow_start_points,
+ "dt": 0.05,
+ "virtual_time": 15,
+ "n_anchors_per_line": 40,
+ "stroke_width": 1,
+ "stroke_color": WHITE,
+ "color_lines_by_magnitude": True,
+ "min_magnitude": 0.5,
+ "max_magnitude": 1.5,
+ "colors": DEFAULT_SCALAR_FIELD_COLORS,
+ }
+
+ def __init__(self, func, **kwargs):
+ VGroup.__init__(self, **kwargs)
+ self.func = func
+ dt = self.dt
+
+ start_points = self.start_points_generator()
+ for point in start_points:
+ points = [point]
+ for t in np.arange(0, self.virtual_time, dt):
+ last_point = points[-1]
+ points.append(last_point + dt * func(last_point))
+ line = VMobject()
+ line.set_points_smoothly(
+ points[::(len(points) / self.n_anchors_per_line)]
+ )
+ self.add(line)
+
+ self.set_stroke(self.stroke_color, self.stroke_width)
+
+ if self.color_lines_by_magnitude:
+ image_file = get_color_field_image_file(
+ lambda p: np.linalg.norm(func(p)),
+ min_value=self.min_magnitude,
+ max_value=self.max_magnitude,
+ colors=self.colors,
+ )
+ self.color_using_background_image(image_file)
+
+
+class ShowPassingFlashWithThinningStrokeWidth(AnimationGroup):
+ CONFIG = {
+ "n_segments": 10,
+ "time_width": 0.1,
+ "remover": True
+ }
+
+ def __init__(self, vmobject, **kwargs):
+ digest_config(self, kwargs)
+ max_stroke_width = vmobject.get_stroke_width()
+ max_time_width = kwargs.pop("time_width", self.time_width)
+ AnimationGroup.__init__(self, *[
+ ShowPassingFlash(
+ vmobject.deepcopy().set_stroke(width=stroke_width),
+ time_width=time_width,
+ **kwargs
+ )
+ for stroke_width, time_width in zip(
+ np.linspace(0, max_stroke_width, self.n_segments),
+ np.linspace(max_time_width, 0, self.n_segments)
+ )
+ ])
+
+
+class StreamLineAnimation(ContinualAnimation):
+ CONFIG = {
+ "lag_range": 4,
+ "line_anim_class": ShowPassingFlashWithThinningStrokeWidth,
+ "line_anim_config": {
+ "run_time": 4,
+ "rate_func": None,
+ "time_width": 0.3,
+ },
+ }
+
+ def __init__(self, stream_lines, **kwargs):
+ digest_config(self, kwargs)
+ self.stream_lines = stream_lines
+ group = VGroup()
+ for line in stream_lines:
+ line.anim = self.line_anim_class(line, **self.line_anim_config)
+ line.time = -self.lag_range * random.random()
+ group.add(line.anim.mobject)
+ ContinualAnimation.__init__(self, group, **kwargs)
+
+ def update_mobject(self, dt):
+ stream_lines = self.stream_lines
+ for line in stream_lines:
+ line.time += dt
+ adjusted_time = max(line.time, 0) % line.anim.run_time
+ line.anim.update(adjusted_time / line.anim.run_time)
+
+# Scenes
+
+
+class TestVectorField(Scene):
+ CONFIG = {
+ "func": cylinder_flow_vector_field,
+ "flow_time": 15,
+ }
+
+ def construct(self):
+ plane = ComplexPlane()
+ self.add(plane)
+
+ circle = Circle(stroke_color=YELLOW)
+ circle.set_fill(BLACK, 1)
+ self.add_foreground_mobject(circle)
+
+ lines = StreamLines(
+ self.func,
+ start_points_generator=lambda: get_flow_start_points(
+ x_min=-8, x_max=-7, y_min=-4, y_max=4,
+ delta_x=0.5, delta_y=0.1,
+ n_repeats=1,
+ noise_factor=0.1,
+ ),
+ stroke_width=2,
+ )
+ # self.add(lines)
+ # self.play(ShowPassingFlashWithThinningStrokeWidth(lines[5], run_time=4))
+ # return
+ stream_line_animation = StreamLineAnimation(lines)
+ self.add(stream_line_animation)
+ self.wait(self.flow_time)
+ # self.play(VFadeOut(lines))
+ # self.remove(stream_line_animation)
+ # self.wait()
+
+ # dots = VGroup(*[
+ # Dot().move_to(start_point)
+ # for start_point in get_flow_start_points()
+ # ])
+ # dots.set_color_by_gradient(YELLOW, RED)
+ # self.add(dots)
+
+ # self.add(VectorFieldSubmobjectFlow(dots, self.func))
+ # self.wait(5)
+
+
+class Introduction(Scene):
+ CONFIG = {
+
+ }
+
+ def construct(self):
+ self.add_plane()
+ self.show_numbers()
+ self.show_contour_lines()
+ self.show_flow()
+ self.apply_joukowsky_map()
+
+ def add_plane(self):
+ self.plane = ComplexPlane()
+ self.plane.add_coordinates()
+ self.plane.coordinate_labels.submobjects.pop(-1)
+ self.add(self.plane)
+
+ def show_numbers(self):
+ title = TextMobject("Complex Plane")
+ title.scale(1.5)
+ title.to_edge(UP, buff=MED_SMALL_BUFF)
+ title.add_background_rectangle()
+ self.add(title)
+
+ unit_circle = Circle(radius=self.plane.unit_size)
+ unit_circle.set_color(YELLOW)
+ dot = Dot()
+ dot_update = UpdateFromFunc(
+ dot, lambda d: d.move_to(unit_circle.point_from_proportion(1))
+ )
+ exp_tex = TexMobject("e^{", "0.00", "i}")
+ zero = exp_tex.get_part_by_tex("0.00")
+ zero.fade(1)
+ exp_tex_update = UpdateFromFunc(
+ exp_tex, lambda et: et.next_to(dot, UR, SMALL_BUFF)
+ )
+ exp_decimal = DecimalNumber(
+ 0, num_decimal_places=2,
+ include_background_rectangle=True,
+ color=YELLOW
+ )
+ exp_decimal.replace(zero)
+ exp_decimal_update = ChangeDecimalToValue(
+ exp_decimal, TAU,
+ position_update_func=lambda mob: mob.move_to(zero),
+ run_time=4,
+ )
+
+ self.play(
+ ShowCreation(unit_circle, run_time=4),
+ VFadeIn(exp_tex),
+ UpdateFromAlphaFunc(
+ exp_decimal,
+ lambda ed, a: ed.set_fill(opacity=a)
+ ),
+ dot_update,
+ exp_tex_update,
+ exp_decimal_update,
+ )
+
+ def show_contour_lines(self):
+ pass
+
+ def show_flow(self):
+ pass
+
+ def apply_joukowsky_map(self):
+ pass