Grupos

Hasta ahora hemos visto como trabajar con objetos individuales. Sin embargo, a lo largo de los ejemplos hemos visto que se pueden agrupar Mobjects para realizar diferentes acciones.

Group y VGroup

Los Mobjects genéricos se pueden agrupar utilizando la clase Group.

from manim import *
from pathlib import Path

class MobjectsExample(Scene):
    def construct(self):
        geometric_figure_example = Square()
        vertices = [1, 2, 3, 4, 5, 6, 7, 8]
        edges = [(1, 7), (1, 8), (2, 3), (2, 4), (2, 5),
                (2, 8), (3, 4), (6, 1), (6, 2),
                (6, 3), (7, 2), (7, 4)]
        graph_example = Graph(
            vertices,
            edges,
            layout="circular",
            layout_scale=3,
            labels={
                v: Text(str(v), font_size=24, color=BLACK)
                for v in vertices
            },
            vertex_config={
                7: {"fill_color": RED}
            },
            edge_config={
                (1, 7): {"stroke_color": RED},
                (2, 7): {"stroke_color": RED},
                (4, 7): {"stroke_color": RED}
            }
        ).scale(0.3)
        text_example = Text("Welcome to Manim!")
        image_example = ImageMobject(Path("assets")/"python_example_logo.jpeg")

        mobjects_group = Group(
            geometric_figure_example,
            graph_example,
            text_example,
            image_example
        ).arrange_in_grid()

        self.add(mobjects_group)

Los Group actúan como una fusión entre un Mobject y un array o una lista, de forma que podemos seleccionar los objetos por índice, agregar más objetos al grupo, quitarlos, reemplazarlos o iterar sobre ellos, pero también podemos usarlo para agregarlos a una escena como en el ejemplo de arriba.

Por otro lado, tenemos los VGroup, que se utiliza específicamente cuando trabajamos con VMobjects y queremos conservar algunas de sus propiedades vectoriales.

Tanto Group como VGroup nos permiten realizar acciones como alinear con los objetos arrange u ordenarlos en una cuadrícula con arrange_in_grid().

Su principales utilidades son poder tratar varios objetos como uno solo y poder iterar sobre ellos.

VDict

Si Group y VGroup se comportan como un array de Mobjects y VMobjects, VDict se comporta como un diccionario para VMobjects, de forma que podemos ir agrupando los VMobjects por pares clave-valor.

Esto es muy útil si tenemos muchos objetos y queremos poder interactuar con ellos de forma independiente sin tener que preocuparnos mucho por su índice o si queremos enumerar objetos fácilmente.

from manim import *


class VDictExample(Scene):
    def construct(self):
        dots = VDict(
            [
                (1, Dot(color=RED)),
                (2, Dot(color=YELLOW)),
                (3, Dot(color=GREEN)),
            ]
        )

        # We can apply multiple operations to a single object
        # and it will apply to all
        dots.arrange(RIGHT).scale(5)

        # Show only the elements with keys 1 and 3
        self.add(dots[1], dots[3])

¡Ejercicios!

Ejercicio 1

Crea un VGroup que parezca un semáforo. Basta algo aproximado. Si no recuerdas en qué orden van los colores, aquí te dejo una imagen:

Solución al ejercicio 1

from manim import *

class GroupsExerciseOne(Scene):
    LIGHTS_RADIUS = 0.4
    def construct(self):
        rect = RoundedRectangle(height=3.5, width=1.5, fill_opacity=1, color=GOLD_D)
        red_light = Circle(radius=self.LIGHTS_RADIUS, color=RED, fill_opacity=1)
        yellow_light = Circle(radius=self.LIGHTS_RADIUS, color=YELLOW, fill_opacity=1)
        green_light = Circle(radius=self.LIGHTS_RADIUS, color=GREEN, fill_opacity=1)

        lights_group = VGroup(red_light, yellow_light, green_light).arrange(DOWN).move_to(rect.get_center())
        traffic_light = VGroup(rect, lights_group)

        self.add(traffic_light)

Ejercicio 2

Crea un VGroup que parezca un una montañita de cartas o sobres. Algo así:

Basta con que uses rectángulos o una figura similar.

Solución al ejercicio 2

from manim import *


class GroupsExerciseTwo(Scene):
    def construct(self):
        yellow_card = RoundedRectangle(stroke_color=BLACK, fill_color=YELLOW, fill_opacity=1)
        green_card = RoundedRectangle(stroke_color=BLACK, fill_color=GREEN, fill_opacity=1)
        teal_card = RoundedRectangle(stroke_color=BLACK, fill_color=TEAL, fill_opacity=1)
        blue_card = RoundedRectangle(stroke_color=BLACK, fill_color=BLUE, fill_opacity=1)

        cards = VGroup(blue_card, teal_card, green_card, yellow_card)
        cards.arrange(DOWN, buff=-1.5)

        self.add(cards)