mirror of
https://github.com/3b1b/manim.git
synced 2025-09-01 00:48:45 +00:00
Merge branch 'master' into pr
This commit is contained in:
Grant Sanderson
GitHub
commit
7d5432ce8b
28 changed files with 3680 additions and 104 deletions
15
README.md
15
README.md
|
|
@ -69,3 +69,18 @@ a Dockerfile provided.
|
|||
On a Windows system, make sure to replace `$PWD` with an absolute path to manim.
|
||||
|
||||
Note that the shipped Docker image contains the bare requirements to run manim. To transform the Docker container into a fully-functioning development environment, you will have to edit your personal Dockerfile a bit. For a guide to create your own personal Docker image, consult [this guide to Dockerfiles](https://www.howtoforge.com/tutorial/how-to-create-docker-images-with-dockerfile/).
|
||||
|
||||
## Live Streaming
|
||||
|
||||
To live stream your animations, simply assign `IS_LIVE_STREAMING = True` in `constants.py` file and from your Python Interactive Shell (`python3`) import the stream starter with `from stream_starter import *` while under the project directory. This will provide a clean interactive shell to enter your commands. `manim` object is a `Manim()` instance so as soon as you play an animation with `manim.play()` your stream will start. A video player will pop-up and you can broadcast that video using [OBS Studio](https://obsproject.com/) which is the most practical way of streaming with this math animation library. An example:
|
||||
|
||||
```
|
||||
>>> from stream_starter import *
|
||||
YOUR STREAM IS READY!
|
||||
>>> circle = Circle()
|
||||
>>> manim.play(ShowCreation(circle))
|
||||
Animation 0: ShowCreationCircle: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 60/60 [00:01<00:00, 37.30it/s]
|
||||
<scene.scene.Scene object at 0x7f0756d5a8d0>
|
||||
```
|
||||
|
||||
It is also possible to stream directly to Twitch. To do that simply assign `IS_STREAMING_TO_TWITCH = True` in `constants.py` file and put your Twitch Stream Key to `TWITCH_STREAM_KEY = "YOUR_STREAM_KEY"` and when you follow the above example the stream will directly start on your Twitch channel(with no audio support).
|
||||
|
|
|
|||
411
active_projects/shadows.py
Normal file
411
active_projects/shadows.py
Normal file
|
|
@ -0,0 +1,411 @@
|
|||
from big_ol_pile_of_manim_imports import *
|
||||
|
||||
|
||||
# Helpers
|
||||
def get_shadow(mobject, opacity=0.5):
|
||||
result = mobject.deepcopy()
|
||||
result.apply_function(lambda p: [p[0], p[1], 0])
|
||||
color = interpolate_color(
|
||||
mobject.get_fill_color(), BLACK,
|
||||
mobject.get_fill_opacity()
|
||||
)
|
||||
# color = BLACK
|
||||
result.set_fill(color, opacity=opacity)
|
||||
result.set_stroke(BLACK, 0.5, opacity=opacity)
|
||||
result.set_shade_in_3d(False)
|
||||
return result
|
||||
|
||||
|
||||
def get_boundary_points(shadow, n_points=20):
|
||||
points = shadow.get_points_defining_boundary()
|
||||
return np.array([
|
||||
points[np.argmax(np.dot(points, vect.T))]
|
||||
for vect in compass_directions(n_points)
|
||||
])
|
||||
|
||||
|
||||
def get_area(planar_mobject):
|
||||
boundary = get_boundary_points(planar_mobject, 100)
|
||||
xs = boundary[:, 0]
|
||||
ys = boundary[:, 1]
|
||||
dxs = np.append(xs[-1], xs[:-1]) - xs
|
||||
dys = np.append(ys[-1], ys[:-1]) - ys
|
||||
return abs(sum([
|
||||
0.5 * (x * dy - y * dx)
|
||||
for x, dx, y, dy in zip(xs, dxs, ys, dys)
|
||||
]))
|
||||
|
||||
|
||||
def get_xy_plane_projection_point(p1, p2):
|
||||
"""
|
||||
Draw a line from source to p1 to p2. Where does it
|
||||
intersect the xy plane?
|
||||
"""
|
||||
vect = p2 - p1
|
||||
return p1 - (p1[2] / vect[2]) * vect
|
||||
|
||||
|
||||
# Scenes
|
||||
|
||||
|
||||
class ShowShadows(ThreeDScene):
|
||||
CONFIG = {
|
||||
"object_center": [0, 0, 3],
|
||||
"area_label_center": [0, -1.5, 0],
|
||||
"surface_area": 6.0,
|
||||
"num_reorientations": 10,
|
||||
"camera_config": {
|
||||
"light_source_start_point": 10 * OUT,
|
||||
"frame_center": [0, 0, 0.5],
|
||||
}
|
||||
}
|
||||
|
||||
def setup(self):
|
||||
self.add_plane()
|
||||
self.setup_orientation_trackers()
|
||||
self.setup_object_and_shadow()
|
||||
self.add_shadow_area_label()
|
||||
self.add_surface_area_label()
|
||||
|
||||
def add_plane(self):
|
||||
plane = self.plane = Rectangle(
|
||||
width=FRAME_WIDTH,
|
||||
height=24.2,
|
||||
stroke_width=0,
|
||||
fill_color=WHITE,
|
||||
fill_opacity=0.35,
|
||||
)
|
||||
plane.set_sheen(0.2, DR)
|
||||
grid = NumberPlane(
|
||||
color=LIGHT_GREY,
|
||||
secondary_color=DARK_GREY,
|
||||
y_radius=int(plane.get_height() / 2),
|
||||
stroke_width=1,
|
||||
secondary_line_ratio=0,
|
||||
)
|
||||
plane.add(grid)
|
||||
plane.add(VectorizedPoint(10 * IN))
|
||||
plane.set_shade_in_3d(True, z_index_as_group=True)
|
||||
self.add(plane)
|
||||
|
||||
def setup_orientation_trackers(self):
|
||||
# Euler angles
|
||||
self.alpha_tracker = ValueTracker(0)
|
||||
self.beta_tracker = ValueTracker(0)
|
||||
self.gamma_tracker = ValueTracker(0)
|
||||
|
||||
def setup_object_and_shadow(self):
|
||||
self.obj3d = updating_mobject_from_func(self.get_reoriented_object)
|
||||
self.shadow = updating_mobject_from_func(lambda: get_shadow(self.obj3d))
|
||||
|
||||
def add_shadow_area_label(self):
|
||||
text = TextMobject("Shadow area: ")
|
||||
decimal = DecimalNumber(0)
|
||||
label = VGroup(text, decimal)
|
||||
label.arrange_submobjects(RIGHT)
|
||||
label.scale(1.5)
|
||||
label.move_to(self.area_label_center - decimal.get_center())
|
||||
self.shadow_area_label = label
|
||||
self.shadow_area_decimal = decimal
|
||||
|
||||
# def update_decimal(decimal):
|
||||
# # decimal.set_value(get_area(self.shadow))
|
||||
# self.add_fixed_in_frame_mobjects(decimal)
|
||||
|
||||
# decimal.add_updater(update_decimal)
|
||||
continual_update = ContinualChangingDecimal(
|
||||
decimal,
|
||||
lambda a: get_area(self.shadow),
|
||||
position_update_func=lambda d: self.add_fixed_in_frame_mobjects(d)
|
||||
)
|
||||
|
||||
# self.add_fixed_orientation_mobjects(label)
|
||||
self.add_fixed_in_frame_mobjects(label)
|
||||
self.add(label)
|
||||
self.add(continual_update)
|
||||
|
||||
def add_surface_area_label(self):
|
||||
text = TextMobject("Surface area: ")
|
||||
decimal = DecimalNumber(self.surface_area)
|
||||
label = VGroup(text, decimal)
|
||||
label.arrange_submobjects(RIGHT)
|
||||
label.scale(1.25)
|
||||
label.set_fill(YELLOW)
|
||||
label.set_background_stroke(width=3)
|
||||
label.next_to(self.obj3d, RIGHT, LARGE_BUFF)
|
||||
label.shift(MED_LARGE_BUFF * IN)
|
||||
self.surface_area_label = label
|
||||
self.add_fixed_orientation_mobjects(label)
|
||||
|
||||
def construct(self):
|
||||
# Show creation
|
||||
obj3d = self.obj3d.copy()
|
||||
obj3d.clear_updaters()
|
||||
temp_shadow = updating_mobject_from_func(lambda: get_shadow(obj3d))
|
||||
self.add(temp_shadow)
|
||||
self.move_camera(
|
||||
phi=60 * DEGREES,
|
||||
theta=-120 * DEGREES,
|
||||
added_anims=[
|
||||
LaggedStart(DrawBorderThenFill, obj3d)
|
||||
],
|
||||
run_time=2
|
||||
)
|
||||
self.begin_ambient_camera_rotation(0.01)
|
||||
self.remove(obj3d, temp_shadow)
|
||||
|
||||
average_label = self.get_average_label()
|
||||
# Reorient
|
||||
self.add(self.obj3d, self.shadow)
|
||||
for n in range(self.num_reorientations):
|
||||
self.randomly_reorient()
|
||||
if n == 3:
|
||||
self.add_fixed_in_frame_mobjects(average_label)
|
||||
self.play(Write(average_label, run_time=2))
|
||||
else:
|
||||
self.wait()
|
||||
|
||||
def randomly_reorient(self, run_time=3):
|
||||
a, b, c = TAU * np.random.random(3)
|
||||
self.play(
|
||||
self.alpha_tracker.set_value, a,
|
||||
self.beta_tracker.set_value, b,
|
||||
self.gamma_tracker.set_value, c,
|
||||
run_time=run_time
|
||||
)
|
||||
|
||||
#
|
||||
def get_object(self):
|
||||
cube = Cube()
|
||||
cube.set_height(1)
|
||||
# cube.set_width(2, stretch=True)
|
||||
cube.set_stroke(WHITE, 0.5)
|
||||
return cube
|
||||
|
||||
def get_reoriented_object(self):
|
||||
obj3d = self.get_object()
|
||||
angles = [
|
||||
self.alpha_tracker.get_value(),
|
||||
self.beta_tracker.get_value(),
|
||||
self.gamma_tracker.get_value(),
|
||||
]
|
||||
vects = [OUT, RIGHT, OUT]
|
||||
|
||||
center = self.object_center
|
||||
obj3d.move_to(center)
|
||||
for angle, vect in zip(angles, vects):
|
||||
obj3d.rotate(angle, vect, about_point=center)
|
||||
return obj3d
|
||||
|
||||
def get_average_label(self):
|
||||
rect = SurroundingRectangle(
|
||||
self.shadow_area_decimal,
|
||||
buff=SMALL_BUFF,
|
||||
color=RED,
|
||||
)
|
||||
words = TextMobject(
|
||||
"Average", "=",
|
||||
"$\\frac{\\text{Surface area}}{4}$"
|
||||
)
|
||||
words.scale(1.5)
|
||||
words[0].match_color(rect)
|
||||
words[2].set_color(self.surface_area_label[0].get_fill_color())
|
||||
words.set_background_stroke(width=3)
|
||||
words.next_to(
|
||||
rect, DOWN,
|
||||
index_of_submobject_to_align=0,
|
||||
)
|
||||
# words.shift(MED_LARGE_BUFF * LEFT)
|
||||
return VGroup(rect, words)
|
||||
|
||||
|
||||
class ShowInfinitelyFarLightSource(ShowShadows):
|
||||
CONFIG = {
|
||||
"num_reorientations": 1,
|
||||
"camera_center": [0, 0, 1],
|
||||
}
|
||||
|
||||
def construct(self):
|
||||
self.force_skipping()
|
||||
ShowShadows.construct(self)
|
||||
self.revert_to_original_skipping_status()
|
||||
|
||||
self.add_light_source_based_shadow_updater()
|
||||
self.add_light()
|
||||
self.move_light_around()
|
||||
self.show_vertical_lines()
|
||||
|
||||
def add_light(self):
|
||||
light = self.light = self.get_light()
|
||||
light_source = self.camera.light_source
|
||||
light.move_to(light_source)
|
||||
light_source.add_updater(lambda m: m.move_to(light))
|
||||
self.add(light_source)
|
||||
self.add_fixed_orientation_mobjects(light)
|
||||
|
||||
def move_light_around(self):
|
||||
light = self.light
|
||||
self.add_foreground_mobjects(self.shadow_area_label)
|
||||
self.play(
|
||||
light.move_to, 5 * OUT + DOWN,
|
||||
run_time=3
|
||||
)
|
||||
self.play(Rotating(
|
||||
light, angle=TAU, about_point=5 * OUT,
|
||||
rate_func=smooth, run_time=3
|
||||
))
|
||||
self.play(
|
||||
light.move_to, 30 * OUT,
|
||||
run_time=3,
|
||||
)
|
||||
self.remove(light)
|
||||
|
||||
def show_vertical_lines(self):
|
||||
lines = self.get_vertical_lines()
|
||||
obj3d = self.obj3d
|
||||
shadow = self.shadow
|
||||
target_obj3d = obj3d.copy()
|
||||
target_obj3d.become(shadow)
|
||||
target_obj3d.match_style(obj3d)
|
||||
target_obj3d.set_shade_in_3d(False)
|
||||
source_obj3d = obj3d.copy()
|
||||
source_obj3d.set_shade_in_3d(False)
|
||||
source_obj3d.fade(1)
|
||||
|
||||
self.play(LaggedStart(ShowCreation, lines))
|
||||
self.wait()
|
||||
self.add(source_obj3d, lines)
|
||||
self.play(
|
||||
ReplacementTransform(source_obj3d, target_obj3d),
|
||||
run_time=2
|
||||
)
|
||||
self.add(target_obj3d, lines)
|
||||
self.play(FadeOut(target_obj3d),)
|
||||
self.wait()
|
||||
lines.add_updater(lambda m: m.become(self.get_vertical_lines()))
|
||||
for x in range(5):
|
||||
self.randomly_reorient()
|
||||
|
||||
def add_light_source_based_shadow_updater(self):
|
||||
shadow = self.shadow
|
||||
light_source = self.camera.light_source
|
||||
obj3d = self.obj3d
|
||||
center = obj3d.get_center()
|
||||
|
||||
def update(shadow):
|
||||
lsp = light_source.get_center()
|
||||
proj_center = get_xy_plane_projection_point(lsp, center)
|
||||
c_to_lsp = lsp - center
|
||||
unit_c_to_lsp = normalize(c_to_lsp)
|
||||
rotation = rotation_matrix(
|
||||
angle=np.arccos(np.dot(unit_c_to_lsp, OUT)),
|
||||
axis=normalize(np.cross(unit_c_to_lsp, OUT))
|
||||
)
|
||||
new_shadow = get_shadow(
|
||||
self.obj3d.copy().apply_matrix(rotation)
|
||||
)
|
||||
shadow.become(new_shadow)
|
||||
shadow.scale(get_norm(lsp) / get_norm(c_to_lsp))
|
||||
shadow.move_to(proj_center)
|
||||
return shadow
|
||||
shadow.add_updater(update)
|
||||
|
||||
def get_light(self):
|
||||
n_rings = 40
|
||||
radii = np.linspace(0, 2, n_rings)
|
||||
rings = VGroup(*[
|
||||
Annulus(inner_radius=r1, outer_radius=r2)
|
||||
for r1, r2 in zip(radii, radii[1:])
|
||||
])
|
||||
opacities = np.linspace(1, 0, n_rings)**1.5
|
||||
for opacity, ring in zip(opacities, rings):
|
||||
ring.set_fill(YELLOW, opacity)
|
||||
ring.set_stroke(YELLOW, width=0.1, opacity=opacity)
|
||||
return rings
|
||||
|
||||
def get_vertical_lines(self):
|
||||
shadow = self.shadow
|
||||
points = get_boundary_points(shadow, 10)
|
||||
# half_points = [(p1 + p2) / 2 for p1, p2 in adjacent_pairs(points)]
|
||||
# points = np.append(points, half_points, axis=0)
|
||||
light_source = self.light.get_center()
|
||||
lines = VGroup(*[
|
||||
DashedLine(light_source, point)
|
||||
for point in points
|
||||
])
|
||||
lines.set_shade_in_3d(True)
|
||||
for line in lines:
|
||||
line.remove(*line[:int(0.8 * len(line))])
|
||||
line[-10:].set_shade_in_3d(False)
|
||||
line.set_stroke(YELLOW, 1)
|
||||
return lines
|
||||
|
||||
|
||||
class CylinderShadows(ShowShadows):
|
||||
CONFIG = {
|
||||
"surface_area": 2 * PI + 2 * PI * 2,
|
||||
"area_label_center": [0, -2, 0],
|
||||
}
|
||||
|
||||
def get_object(self):
|
||||
height = 2
|
||||
cylinder = ParametricSurface(
|
||||
lambda u, v: np.array([
|
||||
np.cos(TAU * v),
|
||||
np.sin(TAU * v),
|
||||
height * (1 - u)
|
||||
]),
|
||||
resolution=(6, 32)
|
||||
)
|
||||
# circle = Circle(radius=1)
|
||||
circle = ParametricSurface(
|
||||
lambda u, v: np.array([
|
||||
(v + 0.01) * np.cos(TAU * u),
|
||||
(v + 0.01) * np.sin(TAU * u),
|
||||
0,
|
||||
]),
|
||||
resolution=(16, 8)
|
||||
)
|
||||
# circle.set_fill(GREEN, opacity=0.5)
|
||||
for surface in cylinder, circle:
|
||||
surface.set_fill_by_checkerboard(GREEN, GREEN_E, opacity=1.0)
|
||||
# surface.set_fill(GREEN, opacity=0.5)
|
||||
cylinder.add(circle)
|
||||
cylinder.add(circle.copy().flip().move_to(height * OUT))
|
||||
cylinder.set_shade_in_3d(True)
|
||||
cylinder.set_stroke(width=0)
|
||||
cylinder.scale(1.003)
|
||||
return cylinder
|
||||
|
||||
|
||||
class PrismShadows(ShowShadows):
|
||||
CONFIG = {
|
||||
"surface_area": 3 * np.sqrt(3) / 2 + 3 * (np.sqrt(3) * 2),
|
||||
"object_center": [0, 0, 3],
|
||||
"area_label_center": [0, -2.25, 0],
|
||||
}
|
||||
|
||||
def get_object(self):
|
||||
height = 2
|
||||
prism = VGroup()
|
||||
triangle = RegularPolygon(3)
|
||||
verts = triangle.get_anchors()[:3]
|
||||
rects = [
|
||||
Polygon(v1, v2, v2 + height * OUT, v1 + height * OUT)
|
||||
for v1, v2 in adjacent_pairs(verts)
|
||||
]
|
||||
prism.add(triangle, *rects)
|
||||
prism.add(triangle.copy().shift(height * OUT))
|
||||
triangle.reverse_points()
|
||||
prism.set_shade_in_3d(True)
|
||||
prism.set_fill(PINK, 0.8)
|
||||
prism.set_stroke(WHITE, 1)
|
||||
return prism
|
||||
|
||||
|
||||
class TheseFourPiAreSquare(PiCreatureScene):
|
||||
def construct(self):
|
||||
pass
|
||||
|
||||
def create_pi_creatures(self):
|
||||
pass
|
||||
|
|
@ -98,6 +98,7 @@ class Write(DrawBorderThenFill):
|
|||
mobject = TextMobject(mob_or_text)
|
||||
else:
|
||||
mobject = mob_or_text
|
||||
|
||||
if "run_time" not in kwargs:
|
||||
self.establish_run_time(mobject)
|
||||
if "lag_factor" not in kwargs:
|
||||
|
|
|
|||
|
|
@ -56,6 +56,7 @@ from mobject.three_dimensions import *
|
|||
from mobject.types.image_mobject import *
|
||||
from mobject.types.point_cloud_mobject import *
|
||||
from mobject.types.vectorized_mobject import *
|
||||
from mobject.updater import *
|
||||
from mobject.value_tracker import *
|
||||
|
||||
from for_3b1b_videos.common_scenes import *
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@ from utils.simple_functions import clip_in_place
|
|||
|
||||
class ThreeDCamera(Camera):
|
||||
CONFIG = {
|
||||
"sun_vect": 5 * UP + LEFT,
|
||||
"shading_factor": 0.2,
|
||||
"distance": 20.0,
|
||||
"default_distance": 5.0,
|
||||
|
|
@ -167,7 +166,7 @@ class ThreeDCamera(Camera):
|
|||
distance = self.get_distance()
|
||||
rot_matrix = self.get_rotation_matrix()
|
||||
|
||||
points -= frame_center
|
||||
points = points - frame_center
|
||||
points = np.dot(points, rot_matrix.T)
|
||||
zs = points[:, 2]
|
||||
for i in 0, 1:
|
||||
|
|
@ -184,7 +183,7 @@ class ThreeDCamera(Camera):
|
|||
factor[(distance - zs) < 0] = 10**6
|
||||
# clip_in_place(factor, 0, 10**6)
|
||||
points[:, i] *= factor
|
||||
points += frame_center
|
||||
points = points + frame_center
|
||||
return points
|
||||
|
||||
def project_point(self, point):
|
||||
|
|
|
|||
22
constants.py
22
constants.py
|
|
@ -114,11 +114,11 @@ PI = np.pi
|
|||
TAU = 2 * PI
|
||||
DEGREES = TAU / 360
|
||||
|
||||
ANIMATIONS_DIR = os.path.join(MEDIA_DIR, "animations")
|
||||
VIDEO_DIR = os.path.join(MEDIA_DIR, "videos")
|
||||
RASTER_IMAGE_DIR = os.path.join(MEDIA_DIR, "designs", "raster_images")
|
||||
SVG_IMAGE_DIR = os.path.join(MEDIA_DIR, "designs", "svg_images")
|
||||
# TODO, staged scenes should really go into a subdirectory of a given scenes directory
|
||||
STAGED_SCENES_DIR = os.path.join(ANIMATIONS_DIR, "staged_scenes")
|
||||
STAGED_SCENES_DIR = os.path.join(VIDEO_DIR, "staged_scenes")
|
||||
###
|
||||
THIS_DIR = os.path.dirname(os.path.realpath(__file__))
|
||||
FILE_DIR = os.path.join(THIS_DIR, "files")
|
||||
|
|
@ -128,7 +128,7 @@ TEX_IMAGE_DIR = TEX_DIR # TODO, What is this doing?
|
|||
MOBJECT_DIR = os.path.join(FILE_DIR, "mobjects")
|
||||
IMAGE_MOBJECT_DIR = os.path.join(MOBJECT_DIR, "image")
|
||||
|
||||
for folder in [FILE_DIR, RASTER_IMAGE_DIR, SVG_IMAGE_DIR, ANIMATIONS_DIR, TEX_DIR,
|
||||
for folder in [FILE_DIR, RASTER_IMAGE_DIR, SVG_IMAGE_DIR, VIDEO_DIR, TEX_DIR,
|
||||
TEX_IMAGE_DIR, MOBJECT_DIR, IMAGE_MOBJECT_DIR,
|
||||
STAGED_SCENES_DIR]:
|
||||
if not os.path.exists(folder):
|
||||
|
|
@ -136,8 +136,10 @@ for folder in [FILE_DIR, RASTER_IMAGE_DIR, SVG_IMAGE_DIR, ANIMATIONS_DIR, TEX_DI
|
|||
|
||||
TEX_USE_CTEX = False
|
||||
TEX_TEXT_TO_REPLACE = "YourTextHere"
|
||||
TEMPLATE_TEX_FILE = os.path.join(THIS_DIR, "tex_template.tex" if not TEX_USE_CTEX
|
||||
else "ctex_template.tex")
|
||||
TEMPLATE_TEX_FILE = os.path.join(
|
||||
THIS_DIR, "tex_template.tex" if not TEX_USE_CTEX
|
||||
else "ctex_template.tex"
|
||||
)
|
||||
with open(TEMPLATE_TEX_FILE, "r") as infile:
|
||||
TEMPLATE_TEXT_FILE_BODY = infile.read()
|
||||
TEMPLATE_TEX_FILE_BODY = TEMPLATE_TEXT_FILE_BODY.replace(
|
||||
|
|
@ -211,3 +213,13 @@ PALETTE = list(COLOR_MAP.values())
|
|||
locals().update(COLOR_MAP)
|
||||
for name in [s for s in list(COLOR_MAP.keys()) if s.endswith("_C")]:
|
||||
locals()[name.replace("_C", "")] = locals()[name]
|
||||
|
||||
# Streaming related configurations
|
||||
IS_LIVE_STREAMING = False
|
||||
LIVE_STREAM_NAME = "LiveStream"
|
||||
IS_STREAMING_TO_TWITCH = False
|
||||
TWITCH_STREAM_KEY = "YOUR_STREAM_KEY"
|
||||
STREAMING_PROTOCOL = "tcp"
|
||||
STREAMING_IP = "127.0.0.1"
|
||||
STREAMING_PORT = "2000"
|
||||
STREAMING_CLIENT = "ffplay"
|
||||
|
|
|
|||
|
|
@ -260,7 +260,7 @@ def main():
|
|||
scene_names_to_classes = dict(inspect.getmembers(module, is_scene))
|
||||
|
||||
# config["output_directory"] = os.path.join(
|
||||
# ANIMATIONS_DIR,
|
||||
# VIDEO_DIR,
|
||||
# config["file"].replace(".py", "")
|
||||
# )
|
||||
|
||||
|
|
|
|||
|
|
@ -227,16 +227,16 @@ class PatreonEndScreen(PatreonThanks):
|
|||
RIGHT, buff=LARGE_BUFF,
|
||||
aligned_edge=UP,
|
||||
)
|
||||
columns.set_width(total_width - 1)
|
||||
columns.next_to(black_rect, DOWN, 3 * LARGE_BUFF)
|
||||
columns.to_edge(RIGHT)
|
||||
if columns.get_width() > self.max_patron_width:
|
||||
columns.set_width(total_width - 1)
|
||||
|
||||
thanks.align_to(columns, alignment_vect=RIGHT)
|
||||
thanks.to_edge(RIGHT)
|
||||
columns.next_to(thanks, DOWN, 3 * LARGE_BUFF)
|
||||
|
||||
self.add(columns, black_rect, line, thanks)
|
||||
self.play(
|
||||
columns.move_to, 2 * DOWN, DOWN,
|
||||
columns.to_edge, RIGHT,
|
||||
columns.align_to, thanks, {"alignment_vect": RIGHT},
|
||||
rate_func=None,
|
||||
run_time=self.run_time,
|
||||
)
|
||||
|
|
|
|||
31
manim.py
Normal file
31
manim.py
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
#!/usr/bin/python3
|
||||
|
||||
from constants import *
|
||||
from scene.scene import Scene
|
||||
|
||||
|
||||
class Manim():
|
||||
|
||||
def __new__(cls):
|
||||
kwargs = {
|
||||
"scene_name": LIVE_STREAM_NAME,
|
||||
"open_video_upon_completion": False,
|
||||
"show_file_in_finder": False,
|
||||
# By default, write to file
|
||||
"write_to_movie": True,
|
||||
"show_last_frame": False,
|
||||
"save_pngs": False,
|
||||
# If -t is passed in (for transparent), this will be RGBA
|
||||
"saved_image_mode": "RGB",
|
||||
"movie_file_extension": ".mp4",
|
||||
"quiet": True,
|
||||
"ignore_waits": False,
|
||||
"write_all": False,
|
||||
"name": LIVE_STREAM_NAME,
|
||||
"start_at_animation_number": 0,
|
||||
"end_at_animation_number": None,
|
||||
"skip_animations": False,
|
||||
"camera_config": HIGH_QUALITY_CAMERA_CONFIG,
|
||||
"frame_duration": MEDIUM_QUALITY_FRAME_DURATION,
|
||||
}
|
||||
return Scene(**kwargs)
|
||||
|
|
@ -88,7 +88,7 @@ class Matrix(VMobject):
|
|||
|
||||
def matrix_to_mob_matrix(self, matrix):
|
||||
return np.vectorize(self.element_to_mobject)(
|
||||
matrix
|
||||
matrix, **self.element_to_mobject_config
|
||||
)
|
||||
|
||||
def organize_mob_matrix(self, matrix):
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ class Mobject(Container):
|
|||
|
||||
def save_image(self, name=None):
|
||||
self.get_image().save(
|
||||
os.path.join(ANIMATIONS_DIR, (name or str(self)) + ".png")
|
||||
os.path.join(VIDEO_DIR, (name or str(self)) + ".png")
|
||||
)
|
||||
|
||||
def copy(self):
|
||||
|
|
@ -186,6 +186,7 @@ class Mobject(Container):
|
|||
|
||||
def clear_updaters(self):
|
||||
self.updaters = []
|
||||
return self
|
||||
|
||||
# Transforming operations
|
||||
|
||||
|
|
@ -703,7 +704,7 @@ class Mobject(Container):
|
|||
# Getters
|
||||
|
||||
def get_points_defining_boundary(self):
|
||||
return self.points
|
||||
return self.get_all_points()
|
||||
|
||||
def get_num_points(self):
|
||||
return len(self.points)
|
||||
|
|
@ -743,7 +744,8 @@ class Mobject(Container):
|
|||
|
||||
def get_boundary_point(self, direction):
|
||||
all_points = self.get_points_defining_boundary()
|
||||
return all_points[np.argmax(np.dot(all_points, direction))]
|
||||
index = np.argmax(np.dot(all_points, np.array(direction).T))
|
||||
return all_points[index]
|
||||
|
||||
def get_z_index_reference_point(self):
|
||||
# TODO, better place to define default z_index_group?
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
|
||||
|
||||
import itertools as it
|
||||
from colour import Color
|
||||
|
||||
from mobject.mobject import Mobject
|
||||
|
|
@ -313,6 +313,7 @@ class VMobject(Mobject):
|
|||
submob.shade_in_3d = value
|
||||
if z_index_as_group:
|
||||
submob.z_index_group = self
|
||||
return self
|
||||
|
||||
# Drawing
|
||||
def start_at(self, point):
|
||||
|
|
@ -482,7 +483,9 @@ class VMobject(Mobject):
|
|||
return self.points[::3]
|
||||
|
||||
def get_points_defining_boundary(self):
|
||||
return self.get_anchors()
|
||||
return np.array(list(it.chain(*[
|
||||
sm.get_anchors() for sm in self.get_family()
|
||||
])))
|
||||
|
||||
# Alignment
|
||||
def align_points(self, vmobject):
|
||||
|
|
|
|||
4
mobject/updater.py
Normal file
4
mobject/updater.py
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
def updating_mobject_from_func(func):
|
||||
mob = func()
|
||||
mob.add_updater(lambda m: mob.become(func()))
|
||||
return mob
|
||||
1236
old_projects/borsuk_addition.py
Normal file
1236
old_projects/borsuk_addition.py
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -10,7 +10,7 @@ from big_ol_pile_of_manim_imports import *
|
|||
from script_wrapper import command_line_create_scene
|
||||
|
||||
MOVIE_PREFIX = "counting_in_binary/"
|
||||
BASE_HAND_FILE = os.path.join(ANIMATIONS_DIR, MOVIE_PREFIX, "Base.mp4")
|
||||
BASE_HAND_FILE = os.path.join(VIDEO_DIR, MOVIE_PREFIX, "Base.mp4")
|
||||
FORCED_FRAME_DURATION = 0.02
|
||||
TIME_RANGE = (0, 42)
|
||||
INITIAL_PADDING = 27
|
||||
|
|
@ -84,7 +84,7 @@ class Hand(ImageMobject):
|
|||
def __init__(self, num, small = False, **kwargs):
|
||||
Mobject2D.__init__(self, **kwargs)
|
||||
path = os.path.join(
|
||||
ANIMATIONS_DIR, MOVIE_PREFIX, "images", "Hand%d.png"%num
|
||||
VIDEO_DIR, MOVIE_PREFIX, "images", "Hand%d.png"%num
|
||||
)
|
||||
invert = False
|
||||
if not self.read_in_cached_attrs(path, invert):
|
||||
|
|
@ -160,7 +160,7 @@ class SaveEachNumber(OverHand):
|
|||
OverHand.construct(self)
|
||||
for count in COUNT_TO_FRAME_NUM:
|
||||
path = os.path.join(
|
||||
ANIMATIONS_DIR, MOVIE_PREFIX, "images",
|
||||
VIDEO_DIR, MOVIE_PREFIX, "images",
|
||||
"Hand%d.png"%count
|
||||
)
|
||||
Image.fromarray(self.frames[COUNT_TO_FRAME_NUM[count]]).save(path)
|
||||
|
|
|
|||
|
|
@ -187,7 +187,7 @@ class AboutLinearAlgebra(Scene):
|
|||
\\end{array}
|
||||
\\right)
|
||||
=
|
||||
ac - bc
|
||||
ad - bc
|
||||
""")
|
||||
|
||||
def get_cross_product(self):
|
||||
|
|
|
|||
|
|
@ -108,45 +108,4 @@ class CircularFractalCreation(FractalCreation):
|
|||
"max_order" : 5,
|
||||
"fractal_kwargs" : {"height" : 6},
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1459,6 +1459,7 @@ class GeometryProofLand(Scene):
|
|||
PINK, RED, YELLOW, GREEN, GREEN_A, BLUE,
|
||||
MAROON_E, MAROON_B, YELLOW, BLUE,
|
||||
],
|
||||
"text": "Geometry proof land",
|
||||
}
|
||||
|
||||
def construct(self):
|
||||
|
|
@ -1469,6 +1470,7 @@ class GeometryProofLand(Scene):
|
|||
colors = list(self.colors)
|
||||
random.shuffle(colors)
|
||||
word_outlines.set_color_by_gradient(*colors)
|
||||
word_outlines.set_stroke(width=5)
|
||||
|
||||
circles = VGroup()
|
||||
for letter in word:
|
||||
|
|
@ -1485,14 +1487,16 @@ class GeometryProofLand(Scene):
|
|||
LaggedStart(MoveToTarget, circles),
|
||||
run_time=2
|
||||
)
|
||||
self.add(word_outlines, circles)
|
||||
self.play(LaggedStart(
|
||||
ShowCreationThenDestruction, word_outlines,
|
||||
run_time=4
|
||||
))
|
||||
FadeIn, word_outlines,
|
||||
run_time=3,
|
||||
rate_func=there_and_back,
|
||||
), Animation(circles))
|
||||
self.wait()
|
||||
|
||||
def get_geometry_proof_land_word(self):
|
||||
word = TextMobject("Geometry proof land")
|
||||
word = TextMobject(self.text)
|
||||
word.rotate(-90 * DEGREES)
|
||||
word.scale(0.25)
|
||||
word.shift(3 * RIGHT)
|
||||
|
|
@ -1502,6 +1506,7 @@ class GeometryProofLand(Scene):
|
|||
word.center()
|
||||
word.to_edge(UP)
|
||||
word.set_color_by_gradient(*self.colors)
|
||||
word.set_background_stroke(width=0)
|
||||
return word
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -99,7 +99,7 @@ if __name__ == "__main__":
|
|||
animated_name=name,
|
||||
write_to_movie=True,
|
||||
output_directory=os.path.join(
|
||||
ANIMATIONS_DIR,
|
||||
VIDEO_DIR,
|
||||
"active_projects",
|
||||
"name_animations",
|
||||
),
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ class Hand(ImageMobject):
|
|||
def __init__(self, num, **kwargs):
|
||||
Mobject2D.__init__(self, **kwargs)
|
||||
path = os.path.join(
|
||||
ANIMATIONS_DIR, MOVIE_PREFIX, "images", "Hand%d.png"%num
|
||||
VIDEO_DIR, MOVIE_PREFIX, "images", "Hand%d.png"%num
|
||||
)
|
||||
invert = False
|
||||
if self.read_in_cached_attrs(path, invert):
|
||||
|
|
@ -83,14 +83,14 @@ class EdgeDetection(SceneFromVideo):
|
|||
return "-".join([filename.split(".")[0], str(t1), str(t2)])
|
||||
|
||||
def construct(self, filename, t1, t2):
|
||||
path = os.path.join(ANIMATIONS_DIR, filename)
|
||||
path = os.path.join(VIDEO_DIR, filename)
|
||||
SceneFromVideo.construct(self, path)
|
||||
self.apply_gaussian_blur()
|
||||
self.apply_edge_detection(t1, t2)
|
||||
|
||||
class BufferedCounting(SceneFromVideo):
|
||||
def construct(self):
|
||||
path = os.path.join(ANIMATIONS_DIR, "CountingInBinary.m4v")
|
||||
path = os.path.join(VIDEO_DIR, "CountingInBinary.m4v")
|
||||
time_range = (3, 42)
|
||||
SceneFromVideo.construct(self, path, time_range = time_range)
|
||||
self.buffer_pixels(spreads = (3, 2))
|
||||
|
|
@ -130,7 +130,7 @@ class ClearLeftSide(SceneFromVideo):
|
|||
return scenename
|
||||
|
||||
def construct(self, scenename):
|
||||
path = os.path.join(ANIMATIONS_DIR, MOVIE_PREFIX, scenename + ".mp4")
|
||||
path = os.path.join(VIDEO_DIR, MOVIE_PREFIX, scenename + ".mp4")
|
||||
SceneFromVideo.construct(self, path)
|
||||
self.set_color_region_over_time_range(
|
||||
Region(lambda x, y : x < -1, shape = self.shape)
|
||||
|
|
@ -148,7 +148,7 @@ class DraggedPixels(SceneFromVideo):
|
|||
return args[0]
|
||||
|
||||
def construct(self, video):
|
||||
path = os.path.join(ANIMATIONS_DIR, MOVIE_PREFIX, video+".mp4")
|
||||
path = os.path.join(VIDEO_DIR, MOVIE_PREFIX, video+".mp4")
|
||||
SceneFromVideo.construct(self, path)
|
||||
self.drag_pixels()
|
||||
|
||||
|
|
@ -165,11 +165,11 @@ class DraggedPixels(SceneFromVideo):
|
|||
|
||||
class SaveEachNumber(SceneFromVideo):
|
||||
def construct(self):
|
||||
path = os.path.join(ANIMATIONS_DIR, MOVIE_PREFIX, "ClearLeftSideBufferedCounting.mp4")
|
||||
path = os.path.join(VIDEO_DIR, MOVIE_PREFIX, "ClearLeftSideBufferedCounting.mp4")
|
||||
SceneFromVideo.construct(self, path)
|
||||
for count in COUNT_TO_FRAME_NUM:
|
||||
path = os.path.join(
|
||||
ANIMATIONS_DIR, MOVIE_PREFIX, "images",
|
||||
VIDEO_DIR, MOVIE_PREFIX, "images",
|
||||
"Hand%d.png"%count
|
||||
)
|
||||
Image.fromarray(self.frames[COUNT_TO_FRAME_NUM[count]]).save(path)
|
||||
|
|
@ -184,7 +184,7 @@ class ShowCounting(SceneFromVideo):
|
|||
return filename
|
||||
|
||||
def construct(self, filename):
|
||||
path = os.path.join(ANIMATIONS_DIR, MOVIE_PREFIX, filename + ".mp4")
|
||||
path = os.path.join(VIDEO_DIR, MOVIE_PREFIX, filename + ".mp4")
|
||||
SceneFromVideo.construct(self, path)
|
||||
total_time = len(self.frames)*self.frame_duration
|
||||
for count in range(32):
|
||||
|
|
@ -208,7 +208,7 @@ class ShowFrameNum(SceneFromVideo):
|
|||
return filename
|
||||
|
||||
def construct(self, filename):
|
||||
path = os.path.join(ANIMATIONS_DIR, MOVIE_PREFIX, filename+".mp4")
|
||||
path = os.path.join(VIDEO_DIR, MOVIE_PREFIX, filename+".mp4")
|
||||
SceneFromVideo.construct(self, path)
|
||||
for frame, count in zip(self.frames, it.count()):
|
||||
print(count + "of" + len(self.frames))
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
from big_ol_pile_of_manim_imports import *
|
||||
from active_projects.quaternions import *
|
||||
from old_projects.quaternions import *
|
||||
|
||||
W_COLOR = YELLOW
|
||||
I_COLOR = GREEN
|
||||
|
|
@ -148,6 +148,25 @@ class Gimbal(VGroup):
|
|||
|
||||
# Scenes
|
||||
|
||||
class ButFirst(TeacherStudentsScene):
|
||||
def construct(self):
|
||||
for student in self.students:
|
||||
student.change("surprised")
|
||||
|
||||
self.teacher_says("But first!")
|
||||
self.change_all_student_modes("happy")
|
||||
self.play(RemovePiCreatureBubble(
|
||||
self.teacher,
|
||||
target_mode="raise_right_hand"
|
||||
))
|
||||
self.change_student_modes(
|
||||
*["pondering"] * 3,
|
||||
look_at_arg=self.screen,
|
||||
)
|
||||
self.play(self.teacher.look_at, self.screen)
|
||||
self.wait(4)
|
||||
|
||||
|
||||
class Introduction(QuaternionHistory):
|
||||
CONFIG = {
|
||||
"names_and_quotes": [
|
||||
|
|
@ -767,6 +786,16 @@ class EulerAnglesAndGimbal(ShowSeveralQuaternionRotations):
|
|||
return line
|
||||
|
||||
|
||||
class InterpolationFail(Scene):
|
||||
def construct(self):
|
||||
words = TextMobject(
|
||||
"Sometimes interpolating 3d\\\\"
|
||||
"orientations is tricky..."
|
||||
)
|
||||
words.to_edge(UP)
|
||||
self.add(words)
|
||||
|
||||
|
||||
class QuaternionInterpolation(ShowSeveralQuaternionRotations):
|
||||
def construct(self):
|
||||
self.add_q_tracker()
|
||||
|
|
@ -1354,3 +1383,27 @@ class ExpandOutFullProduct(TeacherStudentsScene):
|
|||
look_at_arg=words
|
||||
)
|
||||
self.wait(5)
|
||||
|
||||
|
||||
class Link(Scene):
|
||||
def construct(self):
|
||||
word = TextMobject("eater.net/quaternions")
|
||||
word.add_background_rectangle()
|
||||
rect = SurroundingRectangle(word)
|
||||
rect.set_color(BLUE)
|
||||
arrow = Vector(UR, color=GREEN)
|
||||
arrow.next_to(rect, UP)
|
||||
arrow.align_to(rect, RIGHT)
|
||||
short_arrow = arrow.copy().scale(0.8, about_edge=DL)
|
||||
|
||||
self.add(word)
|
||||
self.play(
|
||||
ShowCreation(rect),
|
||||
GrowArrow(arrow),
|
||||
)
|
||||
for x in range(10):
|
||||
self.play(Transform(
|
||||
arrow, short_arrow,
|
||||
rate_func=there_and_back,
|
||||
run_time=2
|
||||
))
|
||||
|
|
@ -97,12 +97,6 @@ def stereo_project(mobject, axis=0, r=1, outer_r=10, **kwargs):
|
|||
return mobject
|
||||
|
||||
|
||||
def updating_mobject_from_func(func):
|
||||
mob = func()
|
||||
mob.add_updater(lambda m: mob.become(func()))
|
||||
return mob
|
||||
|
||||
|
||||
class Linus(VGroup):
|
||||
CONFIG = {
|
||||
"body_config": {
|
||||
1786
old_projects/turbulence.py
Normal file
1786
old_projects/turbulence.py
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -5219,19 +5219,21 @@ class Thumbnail(DistanceProductScene):
|
|||
product[i-1:i+2]
|
||||
for i in frac_indices
|
||||
])
|
||||
parts[::2].set_color(GREEN)
|
||||
parts[1::2].set_color(BLUE)
|
||||
parts[::2].set_color(WHITE)
|
||||
parts[1::2].set_color(WHITE)
|
||||
parts[-1].set_color(WHITE)
|
||||
parts[-1].set_stroke(RED, 1)
|
||||
parts[-1].set_background_stroke(color=YELLOW, width=3)
|
||||
parts[-1].scale(1.5, about_edge=LEFT)
|
||||
product[-4:].next_to(product[:-4], DOWN, MED_LARGE_BUFF)
|
||||
product.scale(1.2).center().to_edge(UP)
|
||||
|
||||
new_proof = TextMobject("New proof")
|
||||
new_proof.scale(2.5)
|
||||
new_proof.set_color(YELLOW)
|
||||
new_proof.set_stroke(RED, 0.75)
|
||||
new_proof.next_to(product, DOWN, MED_LARGE_BUFF)
|
||||
# new_proof = TextMobject("New proof")
|
||||
# new_proof.scale(2.5)
|
||||
# new_proof.set_color(YELLOW)
|
||||
# new_proof.set_stroke(RED, 0.75)
|
||||
# new_proof.next_to(product, DOWN, MED_LARGE_BUFF)
|
||||
|
||||
circle = self.circle = Circle(radius=8, color=RED)
|
||||
circle = self.circle = Circle(radius=8, color=YELLOW)
|
||||
circle.move_to(3 * DOWN, DOWN)
|
||||
bottom_dot = Dot(color=BLUE)
|
||||
bottom_dot.move_to(circle.get_bottom())
|
||||
|
|
@ -5260,7 +5262,7 @@ class Thumbnail(DistanceProductScene):
|
|||
self.add(circle)
|
||||
self.add(lights)
|
||||
self.add(product)
|
||||
self.add(new_proof)
|
||||
# self.add(new_proof)
|
||||
self.add(bottom_dot, observer)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -7,13 +7,18 @@ import random
|
|||
import shutil
|
||||
import subprocess as sp
|
||||
import warnings
|
||||
from time import sleep
|
||||
try:
|
||||
import thread # Low-level threading API (Python 2.7)
|
||||
except ImportError:
|
||||
import _thread as thread # Low-level threading API (Python 3.x)
|
||||
|
||||
from tqdm import tqdm as ProgressDisplay
|
||||
|
||||
from constants import *
|
||||
|
||||
from animation.animation import Animation
|
||||
from animation.transform import MoveToTarget
|
||||
from animation.transform import MoveToTarget, ApplyMethod
|
||||
from camera.camera import Camera
|
||||
from continual_animation.continual_animation import ContinualAnimation
|
||||
from mobject.mobject import Mobject
|
||||
|
|
@ -24,6 +29,9 @@ from utils.output_directory_getters import get_image_output_directory
|
|||
|
||||
from container.container import Container
|
||||
|
||||
from mobject.svg.tex_mobject import TextMobject
|
||||
from animation.creation import Write
|
||||
import datetime
|
||||
|
||||
class Scene(Container):
|
||||
CONFIG = {
|
||||
|
|
@ -58,6 +66,7 @@ class Scene(Container):
|
|||
self.frame_num = 0
|
||||
self.current_scene_time = 0
|
||||
self.original_skipping_status = self.skip_animations
|
||||
self.stream_lock = False
|
||||
if self.name is None:
|
||||
self.name = self.__class__.__name__
|
||||
if self.random_seed is not None:
|
||||
|
|
@ -67,6 +76,8 @@ class Scene(Container):
|
|||
self.setup()
|
||||
if self.write_to_movie:
|
||||
self.open_movie_pipe()
|
||||
if IS_LIVE_STREAMING:
|
||||
return None
|
||||
try:
|
||||
self.construct(*self.construct_args)
|
||||
except EndSceneEarlyException:
|
||||
|
|
@ -173,7 +184,7 @@ class Scene(Container):
|
|||
###
|
||||
|
||||
def continual_update(self, dt):
|
||||
for mobject in self.get_mobjects():
|
||||
for mobject in self.get_mobject_family_members():
|
||||
mobject.update(dt)
|
||||
for continual_animation in self.continual_animations:
|
||||
continual_animation.update(dt)
|
||||
|
|
@ -194,7 +205,7 @@ class Scene(Container):
|
|||
return True
|
||||
any_time_based_update = any([
|
||||
len(m.get_time_based_updaters()) > 0
|
||||
for m in self.get_mobjects()
|
||||
for m in self.get_mobject_family_members()
|
||||
])
|
||||
if any_time_based_update:
|
||||
return True
|
||||
|
|
@ -453,6 +464,8 @@ class Scene(Container):
|
|||
raise EndSceneEarlyException()
|
||||
|
||||
def play(self, *args, **kwargs):
|
||||
if IS_LIVE_STREAMING:
|
||||
self.stream_lock = False
|
||||
if len(args) == 0:
|
||||
warnings.warn("Called Scene.play with no animations")
|
||||
return
|
||||
|
|
@ -489,8 +502,25 @@ class Scene(Container):
|
|||
else:
|
||||
self.continual_update(0)
|
||||
self.num_plays += 1
|
||||
|
||||
if IS_LIVE_STREAMING:
|
||||
self.stream_lock = True
|
||||
thread.start_new_thread(self.idle_stream, ())
|
||||
|
||||
return self
|
||||
|
||||
def idle_stream(self):
|
||||
while(self.stream_lock):
|
||||
a = datetime.datetime.now()
|
||||
self.update_frame()
|
||||
n_frames = 1
|
||||
frame = self.get_frame()
|
||||
self.add_frames(*[frame] * n_frames)
|
||||
b = datetime.datetime.now()
|
||||
time_diff = (b - a).total_seconds()
|
||||
if time_diff < self.frame_duration:
|
||||
sleep(self.frame_duration - time_diff)
|
||||
|
||||
def clean_up_animations(self, *animations):
|
||||
for animation in animations:
|
||||
animation.clean_up(self)
|
||||
|
|
@ -608,6 +638,7 @@ class Scene(Container):
|
|||
'-pix_fmt', 'rgba',
|
||||
'-r', str(fps), # frames per second
|
||||
'-i', '-', # The imput comes from a pipe
|
||||
'-c:v', 'h264_nvenc',
|
||||
'-an', # Tells FFMPEG not to expect any audio
|
||||
'-loglevel', 'error',
|
||||
]
|
||||
|
|
@ -622,18 +653,36 @@ class Scene(Container):
|
|||
'-vcodec', 'libx264',
|
||||
'-pix_fmt', 'yuv420p',
|
||||
]
|
||||
command += [temp_file_path]
|
||||
if IS_LIVE_STREAMING:
|
||||
if IS_STREAMING_TO_TWITCH:
|
||||
command += ['-f', 'flv']
|
||||
command += ['rtmp://live.twitch.tv/app/' + TWITCH_STREAM_KEY]
|
||||
else:
|
||||
command += ['-f', 'mpegts']
|
||||
command += [STREAMING_PROTOCOL + '://' + STREAMING_IP + ':' + STREAMING_PORT]
|
||||
else:
|
||||
command += [temp_file_path]
|
||||
# self.writing_process = sp.Popen(command, stdin=sp.PIPE, shell=True)
|
||||
self.writing_process = sp.Popen(command, stdin=sp.PIPE)
|
||||
|
||||
def close_movie_pipe(self):
|
||||
self.writing_process.stdin.close()
|
||||
self.writing_process.wait()
|
||||
if IS_LIVE_STREAMING:
|
||||
return True
|
||||
if os.name == 'nt':
|
||||
shutil.move(*self.args_to_rename_file)
|
||||
else:
|
||||
os.rename(*self.args_to_rename_file)
|
||||
|
||||
def tex(self, latex):
|
||||
eq = TextMobject(latex)
|
||||
anims = []
|
||||
anims.append(Write(eq))
|
||||
for mobject in self.mobjects:
|
||||
anims.append(ApplyMethod(mobject.shift,2*UP))
|
||||
self.play(*anims)
|
||||
|
||||
|
||||
class EndSceneEarlyException(Exception):
|
||||
pass
|
||||
|
|
|
|||
13
stream_starter.py
Normal file
13
stream_starter.py
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
from big_ol_pile_of_manim_imports import *
|
||||
import subprocess
|
||||
from time import sleep
|
||||
from manim import Manim
|
||||
|
||||
if not IS_STREAMING_TO_TWITCH:
|
||||
FNULL = open(os.devnull, 'w')
|
||||
subprocess.Popen([STREAMING_CLIENT, STREAMING_PROTOCOL + '://' + STREAMING_IP + ':' + STREAMING_PORT + '?listen'], stdout=FNULL, stderr=FNULL)
|
||||
sleep(3)
|
||||
|
||||
manim = Manim()
|
||||
|
||||
print("YOUR STREAM IS READY!")
|
||||
|
|
@ -2,7 +2,7 @@ import inspect
|
|||
import os
|
||||
|
||||
from constants import THIS_DIR
|
||||
from constants import ANIMATIONS_DIR
|
||||
from constants import VIDEO_DIR
|
||||
|
||||
|
||||
def add_extension_if_not_present(file_name, extension):
|
||||
|
|
@ -25,7 +25,7 @@ def get_scene_output_directory(scene_class):
|
|||
file_path = os.path.relpath(file_path, THIS_DIR)
|
||||
file_path = file_path.replace(".pyc", "")
|
||||
file_path = file_path.replace(".py", "")
|
||||
return guarantee_existance(os.path.join(ANIMATIONS_DIR, file_path))
|
||||
return guarantee_existance(os.path.join(VIDEO_DIR, file_path))
|
||||
|
||||
|
||||
def get_movie_output_directory(scene_class, camera_config, frame_duration):
|
||||
|
|
|
|||
|
|
@ -170,7 +170,7 @@ def get_unit_normal(v1, v2):
|
|||
|
||||
|
||||
def compass_directions(n=4, start_vect=RIGHT):
|
||||
angle = 2 * np.pi / n
|
||||
angle = TAU / n
|
||||
return np.array([
|
||||
rotate_vector(start_vect, k * angle)
|
||||
for k in range(n)
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue