WIP: ThreeDSlide

Author: jeertmans

example.py

@@ -28,19 +28,20 @@ def construct(self):
         # Each slide MUST end with an animation (a self.wait is considered an animation)
         self.play(dot.animate.move_to(ORIGIN))
 
+
 class ThreeDExample(ThreeDSlide):
     def construct(self):
         axes = ThreeDAxes()
-        circle=Circle()
+        circle = Circle()
 
-        self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
-        self.add(circle,axes)
+        # self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+        self.add(circle, axes)
 
-        self.begin_ambient_camera_rotation(rate=0.1)
+        # self.begin_ambient_camera_rotation(rate=0.1)
         self.pause()
 
-        self.stop_ambient_camera_rotation()
-        self.move_camera(phi=75 * DEGREES, theta=30 * DEGREES)
+        # self.stop_ambient_camera_rotation()
+        # self.move_camera(phi=75 * DEGREES, theta=30 * DEGREES)
         self.wait()
 
         self.start_loop()

manim_slides/main.py

@@ -12,6 +12,7 @@
 def cli():
     pass
 
+
 cli.add_command(present)
 cli.add_command(wizard)
 cli.add_command(init)

manim_slides/present.py

@@ -21,24 +21,33 @@ class State(Enum):
     END = 3
 
     def __str__(self):
-        if self.value == 0: return "Playing"
-        if self.value == 1: return "Paused"
-        if self.value == 2: return "Wait"
-        if self.value == 3: return "End"
+        if self.value == 0:
+            return "Playing"
+        if self.value == 1:
+            return "Paused"
+        if self.value == 2:
+            return "Wait"
+        if self.value == 3:
+            return "End"
         return "..."
 
+
 def now():
     return round(time.time() * 1000)
 
+
 def fix_time(x):
     return x if x > 0 else 1
 
+
 class Presentation:
     def __init__(self, config, last_frame_next: bool = False):
         self.last_frame_next = last_frame_next
         self.slides = config["slides"]
         self.files = config["files"]
 
+        print(self.slides)
+
         self.lastframe = []
 
         self.caps = [None for _ in self.files]
@@ -48,14 +57,15 @@ def __init__(self, config, last_frame_next: bool = False):
     def add_last_slide(self):
         last_slide_end = self.slides[-1]["end_animation"]
         last_animation = len(self.files)
-        self.slides.append(dict(
-            start_animation = last_slide_end,
-            end_animation = last_animation,
-            type = "last",
-            number = len(self.slides) + 1,
-            terminated = False
-        ))
-
+        self.slides.append(
+            dict(
+                start_animation=last_slide_end,
+                end_animation=last_animation,
+                type="last",
+                number=len(self.slides) + 1,
+                terminated=False,
+            )
+        )
 
     def reset(self):
         self.current_animation = 0
@@ -78,7 +88,7 @@ def rewind_slide(self):
         self.current_animation = self.current_slide["start_animation"]
         self.current_cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
 
-    def load_this_cap(self,cap_number):
+    def load_this_cap(self, cap_number):
         if self.caps[cap_number] == None:
             # unload other caps
             for i in range(len(self.caps)):
@@ -135,7 +145,10 @@ def update_state(self, state):
                     self.rewind_slide()
                 elif self.current_slide["type"] == "last":
                     self.current_slide["terminated"] = True
-            elif self.current_slide["type"] == "last" and self.current_slide["end_animation"] == self.current_animation:
+            elif (
+                self.current_slide["type"] == "last"
+                and self.current_slide["end_animation"] == self.current_animation
+            ):
                 state = State.WAIT
             else:
                 # Play next video!
@@ -162,15 +175,19 @@ def __init__(self, presentations, config, start_paused=False, fullscreen=False):
 
         if fullscreen:
             cv2.namedWindow("Video", cv2.WND_PROP_FULLSCREEN)
-            cv2.setWindowProperty("Video", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
+            cv2.setWindowProperty(
+                "Video", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN
+            )
 
     @property
     def current_presentation(self):
         return self.presentations[self.current_presentation_i]
 
     def run(self):
         while True:
-            self.lastframe, self.state = self.current_presentation.update_state(self.state)
+            self.lastframe, self.state = self.current_presentation.update_state(
+                self.state
+            )
             if self.state == State.PLAYING or self.state == State.PAUSED:
                 if self.start_paused:
                     self.state = State.PAUSED
@@ -200,39 +217,34 @@ def show_info(self):
             info,
             f"Animation: {self.current_presentation.current_animation}",
             (grid_x[0], grid_y[0]),
-            *font_args
-        )
-        cv2.putText(
-            info,
-            f"State: {self.state}",
-            (grid_x[1], grid_y[0]),
-            *font_args
+            *font_args,
         )
+        cv2.putText(info, f"State: {self.state}", (grid_x[1], grid_y[0]), *font_args)
 
         cv2.putText(
             info,
             f"Slide {self.current_presentation.current_slide['number']}/{len(self.current_presentation.slides)}",
             (grid_x[0], grid_y[1]),
-            *font_args
+            *font_args,
         )
         cv2.putText(
             info,
             f"Slide Type: {self.current_presentation.current_slide['type']}",
             (grid_x[1], grid_y[1]),
-            *font_args
+            *font_args,
         )
 
         cv2.putText(
             info,
             f"Scene  {self.current_presentation_i + 1}/{len(self.presentations)}",
-            ((grid_x[0]+grid_x[1])//2, grid_y[2]),
-            *font_args
+            ((grid_x[0] + grid_x[1]) // 2, grid_y[2]),
+            *font_args,
         )
 
         cv2.imshow("Info", info)
 
     def handle_key(self):
-        sleep_time = math.ceil(1000/self.current_presentation.fps)
+        sleep_time = math.ceil(1000 / self.current_presentation.fps)
         key = cv2.waitKeyEx(fix_time(sleep_time - self.lag))
 
         if self.config.QUIT.match(key):
@@ -241,7 +253,9 @@ def handle_key(self):
             self.state = State.PAUSED
         elif self.state == State.PAUSED and self.config.PLAY_PAUSE.match(key):
             self.state = State.PLAYING
-        elif self.state == State.WAIT and (self.config.CONTINUE.match(key) or self.config.PLAY_PAUSE.match(key)):
+        elif self.state == State.WAIT and (
+            self.config.CONTINUE.match(key) or self.config.PLAY_PAUSE.match(key)
+        ):
             self.current_presentation.next()
             self.state = State.PLAYING
         elif self.state == State.PLAYING and self.config.CONTINUE.match(key):
@@ -258,7 +272,6 @@ def handle_key(self):
             self.current_presentation.rewind_slide()
             self.state = State.PLAYING
 
-
     def quit(self):
         cv2.destroyAllWindows()
         sys.exit()
@@ -267,10 +280,19 @@ def quit(self):
 @click.command()
 @click.argument("scenes", nargs=-1)
 @config_path_option
-@click.option("--folder", default=FOLDER_PATH, type=click.Path(exists=True, file_okay=False), help="Set slides folder.")
+@click.option(
+    "--folder",
+    default=FOLDER_PATH,
+    type=click.Path(exists=True, file_okay=False),
+    help="Set slides folder.",
+)
 @click.option("--start-paused", is_flag=True, help="Start paused.")
 @click.option("--fullscreen", is_flag=True, help="Fullscreen mode.")
-@click.option("--last-frame-next", is_flag=True, help="Show the next animation first frame as last frame (hack).")
+@click.option(
+    "--last-frame-next",
+    is_flag=True,
+    help="Show the next animation first frame as last frame (hack).",
+)
 @click.help_option("-h", "--help")
 def present(scenes, config_path, folder, start_paused, fullscreen, last_frame_next):
     """Present the different scenes"""
@@ -279,7 +301,9 @@ def present(scenes, config_path, folder, start_paused, fullscreen, last_frame_ne
     for scene in scenes:
         config_file = os.path.join(folder, f"{scene}.json")
         if not os.path.exists(config_file):
-            raise Exception(f"File {config_file} does not exist, check the scene name and make sure to use Slide as your scene base class")
+            raise Exception(
+                f"File {config_file} does not exist, check the scene name and make sure to use Slide as your scene base class"
+            )
         config = json.load(open(config_file))
         presentations.append(Presentation(config, last_frame_next=last_frame_next))
 
@@ -288,5 +312,7 @@ def present(scenes, config_path, folder, start_paused, fullscreen, last_frame_ne
     else:
         config = Config()
 
-    display = Display(presentations, config=config, start_paused=start_paused, fullscreen=fullscreen)
+    display = Display(
+        presentations, config=config, start_paused=start_paused, fullscreen=fullscreen
+    )
     display.run()

manim_slides/slide.py

@@ -9,7 +9,7 @@
 
 class Slide(Scene):
     def __init__(self, *args, output_folder=FOLDER_PATH, **kwargs):
-        super(Slide, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         self.output_folder = output_folder
         self.slides = list()
         self.current_slide = 1
@@ -18,16 +18,19 @@ def __init__(self, *args, output_folder=FOLDER_PATH, **kwargs):
         self.pause_start_animation = 0
 
     def play(self, *args, **kwargs):
-        super(Slide, self).play(*args, **kwargs)
+        print("PLAY", *args, kwargs.items())
+        super().play(*args, **kwargs)
         self.current_animation += 1
 
     def pause(self):
-        self.slides.append(dict(
-            type="slide",
-            start_animation=self.pause_start_animation,
-            end_animation=self.current_animation,
-            number=self.current_slide
-        ))
+        self.slides.append(
+            dict(
+                type="slide",
+                start_animation=self.pause_start_animation,
+                end_animation=self.current_animation,
+                number=self.current_slide,
+            )
+        )
         self.current_slide += 1
         self.pause_start_animation = self.current_animation
 
@@ -36,13 +39,17 @@ def start_loop(self):
         self.loop_start_animation = self.current_animation
 
     def end_loop(self):
-        assert self.loop_start_animation is not None, "You have to start a loop before ending it"
-        self.slides.append(dict(
-            type="loop",
-            start_animation=self.loop_start_animation,
-            end_animation=self.current_animation,
-            number=self.current_slide
-        ))
+        assert (
+            self.loop_start_animation is not None
+        ), "You have to start a loop before ending it"
+        self.slides.append(
+            dict(
+                type="loop",
+                start_animation=self.loop_start_animation,
+                end_animation=self.current_animation,
+                number=self.current_slide,
+            )
+        )
         self.current_slide += 1
         self.loop_start_animation = None
         self.pause_start_animation = self.current_animation
@@ -52,7 +59,7 @@ def render(self, *args, **kwargs):
         max_files_cached = config["max_files_cached"]
         config["max_files_cached"] = float("inf")
 
-        super(Slide, self).render(*args, **kwargs)
+        super().render(*args, **kwargs)
 
         config["max_files_cached"] = max_files_cached
 
@@ -78,12 +85,10 @@ def render(self, *args, **kwargs):
             shutil.copyfile(src_file, dst_file)
             files.append(dst_file)
 
-        f = open(os.path.join(self.output_folder, "%s.json" % (scene_name, )), "w")
-        json.dump(dict(
-            slides=self.slides,
-            files=files
-        ), f)
+        f = open(os.path.join(self.output_folder, "%s.json" % (scene_name,)), "w")
+        json.dump(dict(slides=self.slides, files=files), f)
         f.close()
 
-class ThreeDSlide(ThreeDScene, Slide):
+
+class ThreeDSlide(Slide, ThreeDScene):
     pass

manim_slides/wizard.py

@@ -27,19 +27,24 @@ def wizard(config_path, force, merge):
     """Launch configuration wizard."""
     return _init(config_path, force, merge, skip_interactive=False)
 
+
 @click.command()
 @config_options
 def init(config_path, force, merge, skip_interactive=False):
     """Initialize a new default configuration file."""
     return _init(config_path, force, merge, skip_interactive=True)
 
+
 def _init(config_path, force, merge, skip_interactive=False):
 
     if os.path.exists(config_path):
         click.secho(f"The `{CONFIG_PATH}` configuration file exists")
 
         if not force and not merge:
-            choice = click.prompt("Do you want to continue and (o)verwrite / (m)erge it, or (q)uit?", type=click.Choice(["o", "m", "q"], case_sensitive=False))
+            choice = click.prompt(
+                "Do you want to continue and (o)verwrite / (m)erge it, or (q)uit?",
+                type=click.Choice(["o", "m", "q"], case_sensitive=False),
+            )
 
             force = choice == "o"
             merge = choice == "m"
@@ -52,7 +57,6 @@ def _init(config_path, force, merge, skip_interactive=False):
             click.secho("Exiting.")
             sys.exit(0)
 
-
     config = Config()
 
     if not skip_interactive:

setup.py

@@ -30,7 +30,7 @@
     python_requires=">=3.7",
     install_requires=[
         "click>=8.0",
-        "click-default-group>=1.2"
+        "click-default-group>=1.2",
         "numpy>=1.19.3",
         "pydantic>=1.9.1",
         "opencv-python>=4.6",