Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Removing drawings.py (#665)

kolibril13dd1b3258402c
diff --git a/manim/__init__.py b/manim/__init__.py
index d54257be2..c1515d101 100644
--- a/manim/__init__.py
+++ b/manim/__init__.py
@@ -17,7 +17,6 @@ from .animation.indication import *
from .animation.movement import *
from .animation.numbers import *
from .animation.rotation import *
-from .animation.specialized import *
from .animation.transform import *
from .animation.update import *
@@ -41,7 +40,6 @@ from .mobject.numbers import *
from .mobject.probability import *
from .mobject.shape_matchers import *
from .mobject.svg.brace import *
-from .mobject.svg.drawings import *
from .mobject.svg.svg_mobject import *
from .mobject.svg.tex_mobject import *
from .mobject.svg.text_mobject import *
diff --git a/manim/animation/specialized.py b/manim/animation/specialized.py
deleted file mode 100644
index b4c83ae84..000000000
--- a/manim/animation/specialized.py
+++ /dev/null
@@ -1,85 +0,0 @@
-"""Animations for highly specialiced applications."""
-
-__all__ = ["MoveCar", "Broadcast"]
-
-
-import operator as op
-
-from ..animation.composition import LaggedStart
-from ..animation.transform import ApplyMethod
-from ..animation.transform import Restore
-from ..mobject.geometry import Circle
-from ..mobject.svg.drawings import Car
-from ..mobject.types.vectorized_mobject import VGroup
-from ..utils.config_ops import digest_config
-from ..utils.space_ops import get_norm
-from ..utils.color import BLACK, WHITE
-
-
-class MoveCar(ApplyMethod):
- CONFIG = {
- "moving_forward": True,
- "run_time": 5,
- }
-
- def __init__(self, car, target_point, **kwargs):
- self.check_if_input_is_car(car)
- self.target_point = target_point
- super().__init__(car.move_to, target_point, **kwargs)
-
- def check_if_input_is_car(self, car):
- if not isinstance(car, Car):
- raise TypeError("MoveCar must take in Car object")
-
- def begin(self):
- super().begin()
- car = self.mobject
- distance = get_norm(
- op.sub(
- self.target_mobject.get_right(),
- self.starting_mobject.get_right(),
- )
- )
- if not self.moving_forward:
- distance *= -1
- tire_radius = car.get_tires()[0].get_width() / 2
- self.total_tire_radians = -distance / tire_radius
-
- def interpolate_mobject(self, alpha):
- ApplyMethod.interpolate_mobject(self, alpha)
- if alpha == 0:
- return
- radians = alpha * self.total_tire_radians
- for tire in self.mobject.get_tires():
- tire.rotate_in_place(radians)
-
-
-class Broadcast(LaggedStart):
- CONFIG = {
- "small_radius": 0.0,
- "big_radius": 5,
- "n_circles": 5,
- "start_stroke_width": 8,
- "color": WHITE,
- "remover": True,
- "lag_ratio": 0.2,
- "run_time": 3,
- "remover": True,
- }
-
- def __init__(self, focal_point, **kwargs):
- digest_config(self, kwargs)
- circles = VGroup()
- for x in range(self.n_circles):
- circle = Circle(
- radius=self.big_radius,
- stroke_color=BLACK,
- stroke_width=0,
- )
- circle.add_updater(lambda c: c.move_to(focal_point))
- circle.save_state()
- circle.set_width(self.small_radius * 2)
- circle.set_stroke(self.color, self.start_stroke_width)
- circles.add(circle)
- animations = [Restore(circle) for circle in circles]
- super().__init__(*animations, **kwargs)
diff --git a/manim/mobject/svg/drawings.py b/manim/mobject/svg/drawings.py
deleted file mode 100644
index 73fc2a48d..000000000
--- a/manim/mobject/svg/drawings.py
+++ /dev/null
@@ -1,1010 +0,0 @@
-"""Mobjects representing predefined SVG drawings."""
-
-__all__ = [
- "Lightbulb",
- "BitcoinLogo",
- "Guitar",
- "Speedometer",
- "AoPSLogo",
- "PartyHat",
- "Laptop",
- "PatreonLogo",
- "VideoIcon",
- "VideoSeries",
- "Headphones",
- "Clock",
- "ClockPassesTime",
- "Bubble",
- "SpeechBubble",
- "DoubleSpeechBubble",
- "ThoughtBubble",
- "Car",
- "VectorizedEarth",
- "Logo",
- "DeckOfCards",
- "PlayingCard",
- "SuitSymbol",
-]
-
-
-import itertools as it
-import string
-
-from ... import config
-from ...animation.animation import Animation
-from ...animation.rotation import Rotating
-from ...constants import *
-from ...mobject.geometry import AnnularSector
-from ...mobject.geometry import Arc
-from ...mobject.geometry import Circle
-from ...mobject.geometry import Line
-from ...mobject.geometry import Polygon
-from ...mobject.geometry import Rectangle
-from ...mobject.geometry import Square
-from ...mobject.mobject import Mobject
-from ...mobject.svg.svg_mobject import SVGMobject
-from ...mobject.svg.tex_mobject import MathTex
-from ...mobject.svg.tex_mobject import Tex
-from ...mobject.three_dimensions import Cube
-from ...mobject.types.vectorized_mobject import VGroup
-from ...mobject.types.vectorized_mobject import VMobject
-from ...mobject.types.vectorized_mobject import VectorizedPoint
-from ...utils.bezier import interpolate
-from ...utils.config_ops import digest_config
-from ...utils.rate_functions import linear
-from ...utils.space_ops import angle_of_vector
-from ...utils.space_ops import complex_to_R3
-from ...utils.space_ops import rotate_vector
-from ...utils.color import (
- YELLOW,
- WHITE,
- DARK_GREY,
- MAROON_B,
- PURPLE,
- GREEN,
- BLACK,
- LIGHT_GREY,
- GREY,
- BLUE_B,
- BLUE_D,
-)
-
-
-class Lightbulb(SVGMobject):
- CONFIG = {
- "file_name": "lightbulb",
- "height": 1,
- "stroke_color": YELLOW,
- "stroke_width": 3,
- "fill_color": YELLOW,
- "fill_opacity": 0,
- }
-
-
-class BitcoinLogo(SVGMobject):
- CONFIG = {
- "file_name": "Bitcoin_logo",
- "height": 1,
- "fill_color": "#f7931a",
- "inner_color": WHITE,
- "fill_opacity": 1,
- "stroke_width": 0,
- }
-
- def __init__(self, **kwargs):
- SVGMobject.__init__(self, **kwargs)
- self[0].set_fill(self.fill_color, self.fill_opacity)
- self[1].set_fill(self.inner_color, 1)
-
-
-class Guitar(SVGMobject):
- CONFIG = {
- "file_name": "guitar",
- "height": 2.5,
- "fill_color": DARK_GREY,
- "fill_opacity": 1,
- "stroke_color": WHITE,
- "stroke_width": 0.5,
- }
-
-
-class Speedometer(VMobject):
- CONFIG = {
- "arc_angle": 4 * np.pi / 3,
- "num_ticks": 8,
- "tick_length": 0.2,
- "needle_width": 0.1,
- "needle_height": 0.8,
- "needle_color": YELLOW,
- }
-
- def generate_points(self):
- start_angle = np.pi / 2 + self.arc_angle / 2
- end_angle = np.pi / 2 - self.arc_angle / 2
- self.add(Arc(start_angle=start_angle, angle=-self.arc_angle))
- tick_angle_range = np.linspace(start_angle, end_angle, self.num_ticks)
- for index, angle in enumerate(tick_angle_range):
- vect = rotate_vector(RIGHT, angle)
- tick = Line((1 - self.tick_length) * vect, vect)
- label = MathTex(str(10 * index))
- label.set_height(self.tick_length)
- label.shift((1 + self.tick_length) * vect)
- self.add(tick, label)
-
- needle = Polygon(
- LEFT,
- UP,
- RIGHT,
- stroke_width=0,
- fill_opacity=1,
- fill_color=self.needle_color,
- )
- needle.stretch_to_fit_width(self.needle_width)
- needle.stretch_to_fit_height(self.needle_height)
- needle.rotate(start_angle - np.pi / 2, about_point=ORIGIN)
- self.add(needle)
- self.needle = needle
-
- self.center_offset = self.get_center()
-
- def get_center(self):
- result = VMobject.get_center(self)
- if hasattr(self, "center_offset"):
- result -= self.center_offset
- return result
-
- def get_needle_tip(self):
- return self.needle.get_anchors()[1]
-
- def get_needle_angle(self):
- return angle_of_vector(self.get_needle_tip() - self.get_center())
-
- def rotate_needle(self, angle):
- self.needle.rotate(angle, about_point=self.get_center())
- return self
-
- def move_needle_to_velocity(self, velocity):
- max_velocity = 10 * (self.num_ticks - 1)
- proportion = float(velocity) / max_velocity
- start_angle = np.pi / 2 + self.arc_angle / 2
- target_angle = start_angle - self.arc_angle * proportion
- self.rotate_needle(target_angle - self.get_needle_angle())
- return self
-
-
-class AoPSLogo(SVGMobject):
- CONFIG = {
- "file_name": "aops_logo",
- "height": 1.5,
- }
-
- def __init__(self, **kwargs):
- SVGMobject.__init__(self, **kwargs)
- self.set_stroke(WHITE, width=0)
- colors = [BLUE_E, "#008445", GREEN_B]
- index_lists = [
- (10, 11, 12, 13, 14, 21, 22, 23, 24, 27, 28, 29, 30),
- (0, 1, 2, 3, 4, 15, 16, 17, 26),
- (5, 6, 7, 8, 9, 18, 19, 20, 25),
- ]
- for color, index_list in zip(colors, index_lists):
- for i in index_list:
- self.submobjects[i].set_fill(color, opacity=1)
-
- self.set_height(self.height)
- self.center()
-
-
-class PartyHat(SVGMobject):
- CONFIG = {
- "file_name": "party_hat",
- "height": 1.5,
- "stroke_width": 0,
- "fill_opacity": 1,
- "frills_colors": [MAROON_B, PURPLE],
- "cone_color": GREEN,
- "dots_colors": [YELLOW],
- }
- NUM_FRILLS = 7
- NUM_DOTS = 6
-
- def __init__(self, **kwargs):
- SVGMobject.__init__(self, **kwargs)
- self.set_height(self.height)
-
- self.frills = VGroup(*self[: self.NUM_FRILLS])
- self.cone = self[self.NUM_FRILLS]
- self.dots = VGroup(*self[self.NUM_FRILLS + 1 :])
-
- self.frills.set_color_by_gradient(*self.frills_colors)
- self.cone.set_color(self.cone_color)
- self.dots.set_color_by_gradient(*self.dots_colors)
-
-
-class Laptop(VGroup):
- CONFIG = {
- "width": 3,
- "body_dimensions": [4, 3, 0.05],
- "screen_thickness": 0.01,
- "keyboard_width_to_body_width": 0.9,
- "keyboard_height_to_body_height": 0.5,
- "screen_width_to_screen_plate_width": 0.9,
- "key_color_kwargs": {
- "stroke_width": 0,
- "fill_color": BLACK,
- "fill_opacity": 1,
- },
- "fill_opacity": 1,
- "stroke_width": 0,
- "body_color": LIGHT_GREY,
- "shaded_body_color": GREY,
- "open_angle": np.pi / 4,
- }
-
- def __init__(self, **kwargs):
- super().__init__(**kwargs)
- body = Cube(side_length=1)
- for dim, scale_factor in enumerate(self.body_dimensions):
- body.stretch(scale_factor, dim=dim)
- body.set_width(self.width)
- body.set_fill(self.shaded_body_color, opacity=1)
- body.sort(lambda p: p[2])
- body[-1].set_fill(self.body_color)
- screen_plate = body.copy()
- keyboard = VGroup(
- *[
- VGroup(
- *[Square(**self.key_color_kwargs) for x in range(12 - y % 2)]
- ).arrange(RIGHT, buff=SMALL_BUFF)
- for y in range(4)
- ]
- ).arrange(DOWN, buff=MED_SMALL_BUFF)
- keyboard.stretch_to_fit_width(
- self.keyboard_width_to_body_width * body.get_width(),
- )
- keyboard.stretch_to_fit_height(
- self.keyboard_height_to_body_height * body.get_height(),
- )
- keyboard.next_to(body, OUT, buff=0.1 * SMALL_BUFF)
- keyboard.shift(MED_SMALL_BUFF * UP)
- body.add(keyboard)
-
- screen_plate.stretch(self.screen_thickness / self.body_dimensions[2], dim=2)
- screen = Rectangle(
- stroke_width=0,
- fill_color=BLACK,
- fill_opacity=1,
- )
- screen.replace(screen_plate, stretch=True)
- screen.scale_in_place(self.screen_width_to_screen_plate_width)
- screen.next_to(screen_plate, OUT, buff=0.1 * SMALL_BUFF)
- screen_plate.add(screen)
- screen_plate.next_to(body, UP, buff=0)
- screen_plate.rotate(
- self.open_angle, RIGHT, about_point=screen_plate.get_bottom()
- )
- self.screen_plate = screen_plate
- self.screen = screen
-
- axis = Line(
- body.get_corner(UP + LEFT + OUT),
- body.get_corner(UP + RIGHT + OUT),
- color=BLACK,
- stroke_width=2,
- )
- self.axis = axis
-
- self.add(body, screen_plate, axis)
- self.rotate(5 * np.pi / 12, LEFT, about_point=ORIGIN)
- self.rotate(np.pi / 6, DOWN, about_point=ORIGIN)
-
-
-class PatreonLogo(SVGMobject):
- CONFIG = {
- "file_name": "patreon_logo",
- "fill_color": "#F96854",
- # "fill_color" : WHITE,
- "fill_opacity": 1,
- "stroke_width": 0,
- "width": 4,
- }
-
- def __init__(self, **kwargs):
- SVGMobject.__init__(self, **kwargs)
- self.set_width(self.width)
- self.center()
-
-
-class VideoIcon(SVGMobject):
- CONFIG = {
- "file_name": "video_icon",
- }
-
- def __init__(self, **kwargs):
- SVGMobject.__init__(self, **kwargs)
- self.width = config["frame_width"] / 12.0
- self.center()
- self.set_width(self.width)
- self.set_stroke(color=WHITE, width=0)
- self.set_fill(color=WHITE, opacity=1)
-
-
-class VideoSeries(VGroup):
- CONFIG = {
- "num_videos": 11,
- "gradient_colors": [BLUE_B, BLUE_D],
- }
-
- def __init__(self, **kwargs):
- digest_config(self, kwargs)
- videos = [VideoIcon() for x in range(self.num_videos)]
- VGroup.__init__(self, *videos, **kwargs)
- self.arrange()
- self.set_width(config["frame_width"] - constants.MED_LARGE_BUFF)
- self.set_color_by_gradient(*self.gradient_colors)
-
-
-class Headphones(SVGMobject):
- CONFIG = {
- "file_name": "headphones",
- "height": 2,
- "y_stretch_factor": 0.5,
- "color": GREY,
- }
-
- def __init__(self, **kwargs):
- digest_config(self, kwargs)
- SVGMobject.__init__(self, file_name=self.file_name, **kwargs)
- self.stretch(self.y_stretch_factor, 1)
- self.set_height(self.height)
- self.set_stroke(width=0)
- self.set_fill(color=self.color)
-
-
-class Clock(VGroup):
- CONFIG = {}
-
- def __init__(self, **kwargs):
- circle = Circle(color=WHITE)
- ticks = []
- for x in range(12):
- alpha = x / 12.0
- point = complex_to_R3(np.exp(2 * np.pi * alpha * complex(0, 1)))
- length = 0.2 if x % 3 == 0 else 0.1
- ticks.append(Line(point, (1 - length) * point))
- self.hour_hand = Line(ORIGIN, 0.3 * UP)
- self.minute_hand = Line(ORIGIN, 0.6 * UP)
- # for hand in self.hour_hand, self.minute_hand:
- # #Balance out where the center is
- # hand.add(VectorizedPoint(-hand.get_end()))
-
- VGroup.__init__(self, circle, self.hour_hand, self.minute_hand, *ticks)
-
-
-class ClockPassesTime(Animation):
- CONFIG = {
- "run_time": 5,
- "hours_passed": 12,
- "rate_func": linear,
- }
-
- def __init__(self, clock, **kwargs):
- digest_config(self, kwargs)
- assert isinstance(clock, Clock)
- rot_kwargs = {"axis": OUT, "about_point": clock.get_center()}
- hour_radians = -self.hours_passed * 2 * np.pi / 12
- self.hour_rotation = Rotating(
- clock.hour_hand, radians=hour_radians, **rot_kwargs
- )
- self.hour_rotation.begin()
- self.minute_rotation = Rotating(
- clock.minute_hand, radians=12 * hour_radians, **rot_kwargs
- )
- self.minute_rotation.begin()
- Animation.__init__(self, clock, **kwargs)
-
- def interpolate_mobject(self, alpha):
- for rotation in self.hour_rotation, self.minute_rotation:
- rotation.interpolate_mobject(alpha)
-
-
-class Bubble(SVGMobject):
- CONFIG = {
- "direction": LEFT,
- "center_point": ORIGIN,
- "content_scale_factor": 0.75,
- "height": 5,
- "width": 8,
- "bubble_center_adjustment_factor": 1.0 / 8,
- "file_name": None,
- "fill_color": BLACK,
- "fill_opacity": 0.8,
- "stroke_color": WHITE,
- "stroke_width": 3,
- }
-
- def __init__(self, **kwargs):
- digest_config(self, kwargs, locals())
- if self.file_name is None:
- raise Exception("Must invoke Bubble subclass")
- try:
- SVGMobject.__init__(self, **kwargs)
- except IOError as err:
- self.file_name = os.path.join(FILE_DIR, self.file_name)
- SVGMobject.__init__(self, **kwargs)
- self.center()
- self.stretch_to_fit_height(self.height)
- self.stretch_to_fit_width(self.width)
- if self.direction[0] > 0:
- self.flip()
- self.direction_was_specified = "direction" in kwargs
- self.content = Mobject()
-
- def get_tip(self):
- # TODO, find a better way
- return self.get_corner(DOWN + self.direction) - 0.6 * self.direction
-
- def get_bubble_center(self):
- factor = self.bubble_center_adjustment_factor
- return self.get_center() + factor * self.get_height() * UP
-
- def move_tip_to(self, point):
- mover = VGroup(self)
- if self.content is not None:
- mover.add(self.content)
- mover.shift(point - self.get_tip())
- return self
-
- def flip(self, axis=UP):
- Mobject.flip(self, axis=axis)
- if abs(axis[1]) > 0:
- self.direction = -np.array(self.direction)
- return self
-
- def pin_to(self, mobject):
- mob_center = mobject.get_center()
- want_to_flip = np.sign(mob_center[0]) != np.sign(self.direction[0])
- can_flip = not self.direction_was_specified
- if want_to_flip and can_flip:
- self.flip()
- boundary_point = mobject.get_critical_point(UP - self.direction)
- vector_from_center = 1.0 * (boundary_point - mob_center)
- self.move_tip_to(mob_center + vector_from_center)
- return self
-
- def position_mobject_inside(self, mobject):
- scaled_width = self.content_scale_factor * self.get_width()
- if mobject.get_width() > scaled_width:
- mobject.set_width(scaled_width)
- mobject.shift(self.get_bubble_center() - mobject.get_center())
- return mobject
-
- def add_content(self, mobject):
- self.position_mobject_inside(mobject)
- self.content = mobject
- return self.content
-
- def write(self, *text):
- self.add_content(Tex(*text))
- return self
-
- def resize_to_content(self):
- target_width = self.content.get_width()
- target_width += max(MED_LARGE_BUFF, 2)
- target_height = self.content.get_height()
- target_height += 2.5 * LARGE_BUFF
- tip_point = self.get_tip()
- self.stretch_to_fit_width(target_width)
- self.stretch_to_fit_height(target_height)
- self.move_tip_to(tip_point)
- self.position_mobject_inside(self.content)
-
- def clear(self):
- self.add_content(VMobject())
- return self
-
-
-class SpeechBubble(Bubble):
- CONFIG = {"file_name": "Bubbles_speech.svg", "height": 4}
-
-
-class DoubleSpeechBubble(Bubble):
- CONFIG = {"file_name": "Bubbles_double_speech.svg", "height": 4}
-
-
-class ThoughtBubble(Bubble):
- CONFIG = {
- "file_name": "Bubbles_thought.svg",
- }
-
- def __init__(self, **kwargs):
- Bubble.__init__(self, **kwargs)
- self.submobjects.sort(key=lambda m: m.get_bottom()[1])
-
- def make_green_screen(self):
- self.submobjects[-1].set_fill(GREEN_SCREEN, opacity=1)
- return self
-
-
-class Car(SVGMobject):
- CONFIG = {
- "file_name": "Car",
- "height": 1,
- "color": LIGHT_GREY,
- "light_colors": [BLACK, BLACK],
- }
-
- def __init__(self, **kwargs):
- SVGMobject.__init__(self, **kwargs)
-
- path = self.submobjects[0]
- subpaths = path.get_subpaths()
- path.clear_points()
- for indices in [(0, 1), (2, 3), (4, 6, 7), (5,), (8,)]:
- part = VMobject()
- for index in indices:
- part.append_points(subpaths[index])
- path.add(part)
-
- self.set_height(self.height)
- self.set_stroke(color=WHITE, width=0)
- self.set_fill(self.color, opacity=1)
-
- orientation_line = Line(self.get_left(), self.get_right())
- orientation_line.set_stroke(width=0)
- self.add(orientation_line)
- self.orientation_line = orientation_line
-
- for light, color in zip(self.get_lights(), self.light_colors):
- light.set_fill(color, 1)
- light.is_subpath = False
-
- self.add_treds_to_tires()
-
- def move_to(self, point_or_mobject):
- vect = rotate_vector(UP + LEFT, self.orientation_line.get_angle())
- self.next_to(point_or_mobject, vect, buff=0)
- return self
-
- def get_front_line(self):
- return DashedLine(
- self.get_corner(UP + RIGHT),
- self.get_corner(DOWN + RIGHT),
- color=DISTANCE_COLOR,
- dash_length=0.05,
- )
-
- def add_treds_to_tires(self):
- for tire in self.get_tires():
- radius = tire.get_width() / 2
- center = tire.get_center()
- tred = Line(
- 0.7 * radius * RIGHT, 1.1 * radius * RIGHT, stroke_width=2, color=BLACK
- )
- tred.rotate(PI / 5, about_point=tred.get_end())
- for theta in np.arange(0, 2 * np.pi, np.pi / 4):
- new_tred = tred.copy()
- new_tred.rotate(theta, about_point=ORIGIN)
- new_tred.shift(center)
- tire.add(new_tred)
- return self
-
- def get_tires(self):
- return VGroup(self[1][0], self[1][1])
-
- def get_lights(self):
- return VGroup(self.get_front_light(), self.get_rear_light())
-
- def get_front_light(self):
- return self[1][3]
-
- def get_rear_light(self):
- return self[1][4]
-
-
-class VectorizedEarth(SVGMobject):
- CONFIG = {
- "file_name": "earth",
- "height": 1.5,
- "fill_color": BLACK,
- }
-
- def __init__(self, **kwargs):
- SVGMobject.__init__(self, **kwargs)
- circle = Circle(
- stroke_width=3,
- stroke_color=GREEN,
- fill_opacity=1,
- fill_color=BLUE_C,
- )
- circle.replace(self)
- self.add_to_back(circle)
-
-
-class Logo(VMobject):
- CONFIG = {
- "pupil_radius": 1.0,
- "outer_radius": 2.0,
- "iris_background_blue": "#74C0E3",
- "iris_background_brown": "#8C6239",
- "blue_spike_colors": [
- "#528EA3",
- "#3E6576",
- "#224C5B",
- BLACK,
- ],
- "brown_spike_colors": [
- "#754C24",
- "#603813",
- "#42210b",
- BLACK,
- ],
- "n_spike_layers": 4,
- "n_spikes": 28,
- "spike_angle": TAU / 28,
- }
-
- def __init__(self, **kwargs):
- VMobject.__init__(self, **kwargs)
- self.add_iris_back()
- self.add_spikes()
- self.add_pupil()
-
- def add_iris_back(self):
- blue_iris_back = AnnularSector(
- inner_radius=self.pupil_radius,
- outer_radius=self.outer_radius,
- angle=270 * DEGREES,
- start_angle=180 * DEGREES,
- fill_color=self.iris_background_blue,
- fill_opacity=1,
- stroke_width=0,
- )
- brown_iris_back = AnnularSector(
- inner_radius=self.pupil_radius,
- outer_radius=self.outer_radius,
- angle=90 * DEGREES,
- start_angle=90 * DEGREES,
- fill_color=self.iris_background_brown,
- fill_opacity=1,
- stroke_width=0,
- )
- self.iris_background = VGroup(
- blue_iris_back,
- brown_iris_back,
- )
- self.add(self.iris_background)
-
- def add_spikes(self):
- layers = VGroup()
- radii = np.linspace(
- self.outer_radius,
- self.pupil_radius,
- self.n_spike_layers,
- endpoint=False,
- )
- radii[:2] = radii[1::-1] # Swap first two
- if self.n_spike_layers > 2:
- radii[-1] = interpolate(radii[-1], self.pupil_radius, 0.25)
-
- for radius in radii:
- tip_angle = self.spike_angle
- half_base = radius * np.tan(tip_angle)
- triangle, right_half_triangle = [
- Polygon(
- radius * UP,
- half_base * RIGHT,
- vertex3,
- fill_opacity=1,
- stroke_width=0,
- )
- for vertex3 in (
- half_base * LEFT,
- ORIGIN,
- )
- ]
- left_half_triangle = right_half_triangle.copy()
- left_half_triangle.flip(UP, about_point=ORIGIN)
-
- n_spikes = self.n_spikes
- full_spikes = [
- triangle.copy().rotate(-angle, about_point=ORIGIN)
- for angle in np.linspace(0, TAU, n_spikes, endpoint=False)
- ]
- index = (3 * n_spikes) // 4
- if radius == radii[0]:
- layer = VGroup(*full_spikes)
- layer.rotate(-TAU / n_spikes / 2, about_point=ORIGIN)
- layer.brown_index = index
- else:
- half_spikes = [
- right_half_triangle.copy(),
- left_half_triangle.copy().rotate(
- 90 * DEGREES,
- about_point=ORIGIN,
- ),
- right_half_triangle.copy().rotate(
- 90 * DEGREES,
- about_point=ORIGIN,
- ),
- left_half_triangle.copy(),
- ]
- layer = VGroup(
- *it.chain(
- half_spikes[:1],
- full_spikes[1:index],
- half_spikes[1:3],
- full_spikes[index + 1 :],
- half_spikes[3:],
- )
- )
- layer.brown_index = index + 1
-
- layers.add(layer)
-
- # Color spikes
- blues = self.blue_spike_colors
- browns = self.brown_spike_colors
- for layer, blue, brown in zip(layers, blues, browns):
- index = layer.brown_index
- layer[:index].set_color(blue)
- layer[index:].set_color(brown)
-
- self.spike_layers = layers
- self.add(layers)
-
- def add_pupil(self):
- self.pupil = Circle(
- radius=self.pupil_radius,
- fill_color=BLACK,
- fill_opacity=1,
- stroke_width=0,
- sheen=0.0,
- )
- self.pupil.rotate(90 * DEGREES)
- self.add(self.pupil)
-
- def cut_pupil(self):
- pupil = self.pupil
- center = pupil.get_center()
- new_pupil = VGroup(
- *[
- pupil.copy().pointwise_become_partial(pupil, a, b)
- for (a, b) in [(0.25, 1), (0, 0.25)]
- ]
- )
- for sector in new_pupil:
- sector.add_cubic_bezier_curve_to(
- [sector.points[-1], *[center] * 3, *[sector.points[0]] * 2]
- )
- self.remove(pupil)
- self.add(new_pupil)
- self.pupil = new_pupil
-
- def get_blue_part_and_brown_part(self):
- if len(self.pupil) == 1:
- self.cut_pupil()
- # circle = Circle()
- # circle.set_stroke(width=0)
- # circle.set_fill(BLACK, opacity=1)
- # circle.match_width(self)
- # circle.move_to(self)
- blue_part = VGroup(
- self.iris_background[0],
- *[layer[: layer.brown_index] for layer in self.spike_layers],
- self.pupil[0],
- )
- brown_part = VGroup(
- self.iris_background[1],
- *[layer[layer.brown_index :] for layer in self.spike_layers],
- self.pupil[1],
- )
- return blue_part, brown_part
-
-
-# Cards
-class DeckOfCards(VGroup):
- def __init__(self, **kwargs):
- possible_values = list(map(str, list(range(1, 11)))) + ["J", "Q", "K"]
- possible_suits = ["hearts", "diamonds", "spades", "clubs"]
- VGroup.__init__(
- self,
- *[
- PlayingCard(value=value, suit=suit, **kwargs)
- for value in possible_values
- for suit in possible_suits
- ],
- )
-
-
-class PlayingCard(VGroup):
- CONFIG = {
- "value": None,
- "suit": None,
- "key": None, # String like "8H" or "KS"
- "height": 2,
- "height_to_width": 3.5 / 2.5,
- "card_height_to_symbol_height": 7,
- "card_width_to_corner_num_width": 10,
- "card_height_to_corner_num_height": 10,
- "color": LIGHT_GREY,
- "turned_over": False,
- "possible_suits": ["hearts", "diamonds", "spades", "clubs"],
- "possible_values": list(map(str, list(range(2, 11)))) + ["J", "Q", "K", "A"],
- }
-
- def __init__(self, key=None, **kwargs):
- VGroup.__init__(self, key=key, **kwargs)
-
- def generate_points(self):
- self.add(
- Rectangle(
- height=self.height,
- width=self.height / self.height_to_width,
- stroke_color=WHITE,
- stroke_width=2,
- fill_color=self.color,
- fill_opacity=1,
- )
- )
- if self.turned_over:
- self.set_fill(DARK_GREY)
- self.set_stroke(LIGHT_GREY)
- contents = VectorizedPoint(self.get_center())
- else:
- value = self.get_value()
- symbol = self.get_symbol()
- design = self.get_design(value, symbol)
- corner_numbers = self.get_corner_numbers(value, symbol)
- contents = VGroup(design, corner_numbers)
- self.design = design
- self.corner_numbers = corner_numbers
- self.add(contents)
-
- def get_value(self):
- value = self.value
- if value is None:
- if self.key is not None:
- value = self.key[:-1]
- else:
- value = random.choice(self.possible_values)
- value = string.upper(str(value))
- if value == "1":
- value = "A"
- if value not in self.possible_values:
- raise Exception("Invalid card value")
-
- face_card_to_value = {
- "J": 11,
- "Q": 12,
- "K": 13,
- "A": 14,
- }
- try:
- self.numerical_value = int(value)
- except:
- self.numerical_value = face_card_to_value[value]
- return value
-
- def get_symbol(self):
- suit = self.suit
- if suit is None:
- if self.key is not None:
- suit = dict([(string.upper(s[0]), s) for s in self.possible_suits])[
- string.upper(self.key[-1])
- ]
- else:
- suit = random.choice(self.possible_suits)
- if suit not in self.possible_suits:
- raise Exception("Invalud suit value")
- self.suit = suit
- symbol_height = float(self.height) / self.card_height_to_symbol_height
- symbol = SuitSymbol(suit, height=symbol_height)
- return symbol
-
- def get_design(self, value, symbol):
- if value == "A":
- return self.get_ace_design(symbol)
- if value in list(map(str, list(range(2, 11)))):
- return self.get_number_design(value, symbol)
- else:
- return self.get_face_card_design(value, symbol)
-
- def get_ace_design(self, symbol):
- design = symbol.copy().scale(1.5)
- design.move_to(self)
- return design
-
- def get_number_design(self, value, symbol):
- num = int(value)
- n_rows = {
- 2: 2,
- 3: 3,
- 4: 2,
- 5: 2,
- 6: 3,
- 7: 3,
- 8: 3,
- 9: 4,
- 10: 4,
- }[num]
- n_cols = 1 if num in [2, 3] else 2
- insertion_indices = {
- 5: [0],
- 7: [0],
- 8: [0, 1],
- 9: [1],
- 10: [0, 2],
- }.get(num, [])
-
- top = self.get_top() + symbol.get_height() * DOWN
- bottom = self.get_bottom() + symbol.get_height() * UP
- column_points = [
- interpolate(top, bottom, alpha) for alpha in np.linspace(0, 1, n_rows)
- ]
-
- design = VGroup(*[symbol.copy().move_to(point) for point in column_points])
- if n_cols == 2:
- space = 0.2 * self.get_width()
- column_copy = design.copy().shift(space * RIGHT)
- design.shift(space * LEFT)
- design.add(*column_copy)
- design.add(
- *[
- symbol.copy().move_to(center_of_mass(column_points[i : i + 2]))
- for i in insertion_indices
- ]
- )
- for symbol in design:
- if symbol.get_center()[1] < self.get_center()[1]:
- symbol.rotate_in_place(np.pi)
- return design
-
- def get_face_card_design(self, value, symbol):
- return VGroup()
-
- def get_corner_numbers(self, value, symbol):
- value_mob = Tex(value)
- width = self.get_width() / self.card_width_to_corner_num_width
- height = self.get_height() / self.card_height_to_corner_num_height
- value_mob.set_width(width)
- value_mob.stretch_to_fit_height(height)
- value_mob.next_to(
- self.get_corner(UP + LEFT), DOWN + RIGHT, buff=MED_LARGE_BUFF * width
- )
- value_mob.set_color(symbol.get_color())
- corner_symbol = symbol.copy()
- corner_symbol.set_width(width)
- corner_symbol.next_to(value_mob, DOWN, buff=MED_SMALL_BUFF * width)
- corner_group = VGroup(value_mob, corner_symbol)
- opposite_corner_group = corner_group.copy()
- opposite_corner_group.rotate(np.pi, about_point=self.get_center())
-
- return VGroup(corner_group, opposite_corner_group)
-
-
-class SuitSymbol(SVGMobject):
- CONFIG = {
- "height": 0.5,
- "fill_opacity": 1,
- "stroke_width": 0,
- "red": "#D02028",
- "black": BLACK,
- }
-
- def __init__(self, suit_name, **kwargs):
- digest_config(self, kwargs)
- suits_to_colors = {
- "hearts": self.red,
- "diamonds": self.red,
- "spades": self.black,
- "clubs": self.black,
- }
- if suit_name not in suits_to_colors:
- raise ValueError("Invalid suit name")
- SVGMobject.__init__(self, file_name=suit_name, **kwargs)
-
- color = suits_to_colors[suit_name]
- self.set_stroke(width=0)
- self.set_fill(color, 1)
- self.set_height(self.height)