diff --git a/custom/drawings.py b/custom/drawings.py new file mode 100644 index 0000000..abd1f90 --- /dev/null +++ b/custom/drawings.py @@ -0,0 +1,465 @@ +from manim_imports_ext import * + + +# Related to pi creatures +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) + + from videos.characters.pi_creature import Randolph + randy = Randolph(mode="happy") + randy.set_height(0.6 * self.get_height()) + randy.stretch(0.8, 0) + randy.look(RIGHT) + randy.move_to(self) + randy.shift(0.07 * self.height * (RIGHT + UP)) + self.randy = self.pi_creature = randy + self.add_to_back(randy) + + 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 PartyHat(SVGMobject): + CONFIG = { + "file_name": "party_hat", + "height": 1.5, + "pi_creature": None, + "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) + if self.pi_creature is not None: + self.next_to(self.pi_creature.eyes, UP, buff=0) + + 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 SunGlasses(SVGMobject): + CONFIG = { + "file_name": "sunglasses", + "glasses_width_to_eyes_width": 1.1, + } + + def __init__(self, pi_creature, **kwargs): + SVGMobject.__init__(self, **kwargs) + self.set_stroke(WHITE, width=0) + self.set_fill(GREY, 1) + self.set_width( + self.glasses_width_to_eyes_width * pi_creature.eyes.get_width() + ) + self.move_to(pi_creature.eyes, UP) + + +class Headphones(SVGMobject): + CONFIG = { + "file_name": "headphones", + "height": 2, + "y_stretch_factor": 0.5, + "color": GREY, + } + + def __init__(self, pi_creature=None, **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) + if pi_creature is not None: + eyes = pi_creature.eyes + self.set_height(3 * eyes.get_height()) + self.move_to(eyes, DOWN) + self.shift(DOWN * eyes.get_height() / 4) + + +class Guitar(SVGMobject): + CONFIG = { + "file_name": "guitar", + "height": 2.5, + "fill_color": DARK_GREY, + "fill_opacity": 1, + "stroke_color": WHITE, + "stroke_width": 0.5, + } + + +# 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": GREY_A, + "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, **kwargs) + + self.key = key + 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 = str(value).upper() + 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 Exception: + 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([ + (s[0].upper(), s) + for s in self.possible_suits + ])[self.key[-1].upper()] + 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): + from videos.characters.pi_creature import PiCreature + sub_rect = Rectangle( + stroke_color=BLACK, + fill_opacity=0, + height=0.9 * self.get_height(), + width=0.6 * self.get_width(), + ) + sub_rect.move_to(self) + + # pi_color = average_color(symbol.get_color(), GREY) + pi_color = symbol.get_color() + if Color(pi_color) == Color(BLACK): + pi_color = GREY_D + pi_mode = { + "J": "plain", + "Q": "thinking", + "K": "hooray" + }[value] + pi_creature = PiCreature( + mode=pi_mode, + color=pi_color, + ) + pi_creature.set_width(0.8 * sub_rect.get_width()) + if value in ["Q", "K"]: + prefix = "king" if value == "K" else "queen" + crown = SVGMobject(file_name=prefix + "_crown") + crown.set_stroke(width=0) + crown.set_fill(YELLOW, 1) + crown.stretch_to_fit_width(0.5 * sub_rect.get_width()) + crown.stretch_to_fit_height(0.17 * sub_rect.get_height()) + crown.move_to(pi_creature.eyes.get_center(), DOWN) + pi_creature.add_to_back(crown) + to_top_buff = 0 + else: + to_top_buff = SMALL_BUFF * sub_rect.get_height() + pi_creature.next_to(sub_rect.get_top(), DOWN, to_top_buff) + # pi_creature.shift(0.05*sub_rect.get_width()*RIGHT) + + pi_copy = pi_creature.copy() + pi_copy.rotate(np.pi, about_point=sub_rect.get_center()) + + return VGroup(sub_rect, pi_creature, pi_copy) + + def get_corner_numbers(self, value, symbol): + value_mob = TextMobject(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 Exception("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) + + +# Logos +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 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)