E03 - animations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "372c7b8d",
   "metadata": {},
   "source": [
    "## Mathematical Animations WITH EASE | Ep. 03: Animations\n",
    "\n",
    "This notebook contains the examples discussed in [this video](https://youtu.be/xqENEC1URKk). The cells below contain the final state of the corresponding scene from the video. Feel free to modify the code below and play around, your changes are only local and just visible to you. To add some more new cells, you can use the \"+\" icon above.\n",
    "\n",
    "To run cells, click on them so that they are in focus, then either the \"Run\" button above, or hit `<Shift + Enter>`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea98e0c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from manim import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7144d1c4",
   "metadata": {},
   "source": [
    "These are some useful basic settings for Jupyter notebooks. You can use them by executing the cell, or just skip them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da3c997e",
   "metadata": {},
   "outputs": [],
   "source": [
    "config.media_width = \"80%\"\n",
    "config.verbosity = \"WARNING\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c6f2260",
   "metadata": {},
   "source": [
    "### Part 1: Animation Basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7e37037-c791-4da6-a164-6dbd1a0c0c57",
   "metadata": {},
   "outputs": [],
   "source": [
    "# since v0.18.0 we no longer use the colour module, Manim brings its own Color class now:\n",
    "from manim import ManimColor as Color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dbf143f",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%manim -qm BasicAnimations\n",
    "\n",
    "class BasicAnimations(Scene):\n",
    "    def construct(self):\n",
    "        polys = VGroup(\n",
    "            *[RegularPolygon(5, radius=1, color=Color.from_hsv((j/5, 1.0, 1.0)), fill_opacity=0.5)\n",
    "              for j in range(5)]\n",
    "        ).arrange(RIGHT)\n",
    "        self.play(DrawBorderThenFill(polys), run_time=2)\n",
    "        self.play(\n",
    "            Rotate(polys[0], PI, rate_func=lambda t: t), # rate_func=linear\n",
    "            Rotate(polys[1], PI, rate_func=smooth),  # default behavior for most animations\n",
    "            Rotate(polys[2], PI, rate_func=lambda t: np.sin(t*PI)),\n",
    "            Rotate(polys[3], PI, rate_func=there_and_back),\n",
    "            Rotate(polys[4], PI, rate_func=lambda t: 1 - abs(1-2*t)),\n",
    "            run_time=2\n",
    "        )\n",
    "        self.wait()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc4e4071",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%manim -qm ConflictingAnimations\n",
    "\n",
    "class ConflictingAnimations(Scene):\n",
    "    def construct(self):\n",
    "        s = Square()\n",
    "        self.add(s)\n",
    "        self.play(Rotate(s, PI), Rotate(s, -PI), run_time=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2675444",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%manim -qm LaggingGroup\n",
    "\n",
    "class LaggingGroup(Scene):\n",
    "    def construct(self):\n",
    "        squares = VGroup(*[Square(color=Color.from_hsv((j/20, 1.0, 1.0)), fill_opacity=0.8) for j in range(20)])\n",
    "        squares.arrange_in_grid(4, 5).scale(0.75)\n",
    "        self.play(AnimationGroup(*[FadeIn(s) for s in squares], lag_ratio=0.15))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aa051eb",
   "metadata": {},
   "source": [
    "### Part 2: Animations from Method calls and Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4ef9157",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%manim -qm AnimateSyntax\n",
    "\n",
    "class AnimateSyntax(Scene):\n",
    "    def construct(self):\n",
    "        s = Square(color=GREEN, fill_opacity=0.5)\n",
    "        c = Circle(color=RED, fill_opacity=0.5)\n",
    "        self.add(s, c)\n",
    "        self.play(s.animate.shift(UP), c.animate.shift(DOWN))\n",
    "        self.play(VGroup(s, c).animate.arrange(RIGHT))\n",
    "        self.play(c.animate(rate_func=linear).shift(RIGHT).scale(2))\n",
    "        self.wait()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16b4ad4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%manim -qm AnimateProblem\n",
    "\n",
    "class AnimateProblem(Scene):\n",
    "    def construct(self):\n",
    "        left_square = Square()\n",
    "        right_square = Square()\n",
    "        VGroup(left_square, right_square).arrange(RIGHT, buff=1)\n",
    "        self.add(left_square, right_square)\n",
    "        self.play(left_square.animate.rotate(PI), Rotate(right_square, PI), run_time=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "682741c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%manim -qm AnimationMechanisms\n",
    "\n",
    "class AnimationMechanisms(Scene):\n",
    "    def construct(self):\n",
    "        c = Circle()\n",
    "        \n",
    "        c.generate_target()\n",
    "        c.target.set_fill(color=GREEN, opacity=0.5)\n",
    "        c.target.shift(2*RIGHT + UP).scale(0.5)\n",
    "        \n",
    "        self.add(c)\n",
    "        self.wait()\n",
    "        self.play(MoveToTarget(c))\n",
    "        \n",
    "        s = Square()\n",
    "        s.save_state()\n",
    "        self.play(FadeIn(s))\n",
    "        self.play(s.animate.set_color(PURPLE).set_opacity(0.5).shift(2*LEFT).scale(3))\n",
    "        self.play(s.animate.shift(5*DOWN).rotate(PI/4))\n",
    "        self.wait()\n",
    "        self.play(Restore(s), run_time=2)\n",
    "\n",
    "        self.wait()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec550968",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%manim -qm --disable_caching SimpleCustomAnimation\n",
    "\n",
    "class SimpleCustomAnimation(Scene):\n",
    "    def construct(self):\n",
    "        def spiral_out(mobject, t):\n",
    "            radius = 4 * t\n",
    "            angle = 2*t * 2*PI\n",
    "            mobject.move_to(radius*(np.cos(angle)*RIGHT + np.sin(angle)*UP))\n",
    "            mobject.set_color(Color.from_hsv((t, 1.0, 1.0)))\n",
    "            mobject.set_opacity(1-t)\n",
    "        \n",
    "        d = Dot(color=YELLOW)\n",
    "        self.add(d)\n",
    "        self.play(UpdateFromAlphaFunc(d, spiral_out, run_time=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f0289dc",
   "metadata": {},
   "source": [
    "## Part 3: Anatomy of Animations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f77187e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%manim -qm --disable_caching CustomAnimationExample\n",
    "\n",
    "class Disperse(Animation):\n",
    "    def __init__(self, mobject, dot_radius=0.05, dot_number=100, **kwargs):\n",
    "        super().__init__(mobject, **kwargs)\n",
    "        self.dot_radius = dot_radius\n",
    "        self.dot_number = dot_number\n",
    "    \n",
    "    def begin(self):\n",
    "        dots = VGroup(\n",
    "            *[Dot(radius=self.dot_radius).move_to(self.mobject.point_from_proportion(p))\n",
    "              for p in np.linspace(0, 1, self.dot_number)]\n",
    "        )\n",
    "        for dot in dots:\n",
    "            dot.initial_position = dot.get_center()\n",
    "            dot.shift_vector = 2*(dot.get_center() - self.mobject.get_center())\n",
    "        dots.set_opacity(0)\n",
    "        self.mobject.add(dots)\n",
    "        self.dots = dots\n",
    "        super().begin()\n",
    "        \n",
    "    def clean_up_from_scene(self, scene):\n",
    "        super().clean_up_from_scene(scene)\n",
    "        scene.remove(self.dots)\n",
    "\n",
    "    def interpolate_mobject(self, alpha):\n",
    "        alpha = self.rate_func(alpha)  # manually apply rate function\n",
    "        if alpha <= 0.5:\n",
    "            self.mobject.set_opacity(1 - 2*alpha, family=False)\n",
    "            self.dots.set_opacity(2*alpha)\n",
    "        else:\n",
    "            self.mobject.set_opacity(0)\n",
    "            self.dots.set_opacity(2*(1 - alpha))\n",
    "            for dot in self.dots:\n",
    "                dot.move_to(dot.initial_position + 2*(alpha-0.5)*dot.shift_vector)\n",
    "            \n",
    "            \n",
    "\n",
    "class CustomAnimationExample(Scene):\n",
    "    def construct(self):\n",
    "        st = Star(color=YELLOW, fill_opacity=1).scale(3)\n",
    "        self.add(st)\n",
    "        self.wait()\n",
    "        self.play(Disperse(st, dot_number=200, run_time=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "458121b4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "da84832ebb0d9f15962c004e99a603d020b29d898fa295675ba4ce07c983548c"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}