Refactor Mandelbrot group positioning and enhance bifurcation diagram setup

Author: AlexTatis

presentation/main.py

@@ -789,7 +789,7 @@ def mandelbrot_to_manim(px, py):
         # self.play(FadeIn(bif_points, lag_ratio=0.01), run_time=2)
         # self.wait(0.5)
 
-        mandelbrot_group.next_to(title, DOWN)
+        mandelbrot_group.next_to(title, DOWN).set_x(0)
 
         # Mandelbrot (invertido)
         self.play(FadeIn(mandelbrot_group, lag_ratio=0.01), run_time=2)

presentation/video.py

@@ -139,33 +139,179 @@ def construct(self):
 
 class Testing(ThreeDSlide):
      def construct(self):
-        axes = Axes(
-            x_range=[0.7, 4, 0.2],
-            y_range=[0, 1, 0.2],
-            axis_config={"color": BLUE},
-        )
 
-        labels = axes.get_axis_labels(x_label="r", y_label="x")
 
-        self.play(Create(axes), Write(labels))
+        title = Tex(r"1. Objetivos").to_edge(UP + LEFT)
+
+        
+        axes_top = Axes(
+            x_range=[0, 4, 1],
+            y_range=[0, 1, 0.2],
+            x_length=5,
+            y_length=2.5,
+            axis_config={"color": BLUE}
+        )
+        # Etiquetas
+        labels_top = axes_top.get_axis_labels(x_label="r", y_label="x")
+        
+        # Colocamos este grupo arriba en la pantalla
+        bif_axes_group = VGroup(axes_top, labels_top).to_edge(UP, buff=1.5)
 
+        # 2.2) Función logística
         def logistic_map(r, x):
             return r * x * (1 - x)
 
-        def bifurcation_diagram(r_values, iterations, last):
-            x = np.random.rand(len(r_values))
+        # 2.3) Generador de puntos para el diagrama
+        def bifurcation_diagram(r_values, iterations=1000, last=100):
+            """
+            Devuelve (r, x) tras descartar transitorios.
+            r_values: array de valores de 'r'
+            iterations: número total de iteraciones
+            last: cuántas iteraciones finales graficar
+            """
+            x = np.random.rand(len(r_values))  # condiciones iniciales aleatorias
             for i in range(iterations):
                 x = logistic_map(r_values, x)
-            if i >= (iterations - last):
-                yield r_values, x
+                # Sólo generamos puntos en las últimas 'last' iteraciones
+                if i >= (iterations - last):
+                    yield r_values, x
+
+        # 2.4) Creamos los puntos del diagrama
+        r_values = np.linspace(0, 4.0, 1000)
+        bif_points = VGroup()
+        """     for r, x in bifurcation_diagram(r_values, iterations=1000, last=100):
+            for i in range(len(r)):
+                dot = Dot(
+                    axes_top.coords_to_point(r[i], x[i]),
+                    radius=0.008,
+                    color=WHITE
+                )
+                 #bif_points.add(dot)
+            
+        """
+        # ------------------------------------------------
+        # 3) Conjunto de Mandelbrot (abajo e invertido)
+        # ------------------------------------------------
+        # 3.1) Parámetros para el Mandelbrot
+        RES = 50       # resolución
+        MAX_ITER = 50   # iteraciones máximas
+        XMIN, XMAX = -2, 1
+        YMIN, YMAX = -1.5, 1.5
+
+        # Para dibujar "abajo", crearemos un VGroup y luego lo moveremos
+        mandelbrot_group = VGroup()
+
+        # 3.2) Generamos el fractal píxel a píxel
+        # Definimos un ancho y alto en coordenadas Manim
+        # (para luego ubicarlo centrado bajo el diagrama).
+        fractal_width = 7
+        fractal_height = 7
+
+        # Función para mapear (x, y) real a coordenadas de Manim
+        # centradas, con el mismo ancho que "fractal_width" y alto "fractal_height".
+        def mandelbrot_to_manim(px, py):
+            """ 
+            px, py están en [XMIN, XMAX], [YMIN, YMAX].
+            Devolvemos (X, Y) en la escena, centrados en (0,0) por debajo.
+            """
+            # Proporciones
+            # 1) normalizamos px a [0,1] respecto a [XMIN, XMAX]
+            nx = (px - XMIN) / (XMAX - XMIN)
+            ny = (py - YMIN) / (YMAX - YMIN)
+            # 2) escalamos al tamaño en la escena
+            X = fractal_width * (nx - 0.5)   # -0.5 para centrar en 0
+            Y = fractal_height * (ny - 0.5)  # -0.5 para centrar en 0
+            return np.array([X, Y, 0])
+
+        for i in range(RES):
+            for j in range(RES):
+                # Convertir (i, j) en coordenadas complejas c = x + i y
+                x = XMIN + (XMAX - XMIN) * i / (RES - 1)
+                y = YMIN + (YMAX - YMIN) * j / (RES - 1)
+                c = complex(x, y)
+
+                # Iteramos z_{n+1} = z_n^2 + c
+                z = 0
+                iteration = 0
+                while abs(z) <= 2 and iteration < MAX_ITER:
+                    z = z*z + c
+                    iteration += 1
+
+                # Color según número de iteraciones (negro->blanco simple)
+                color = interpolate_color(BLACK, WHITE, iteration / MAX_ITER)
+
+                # Representamos cada píxel con un cuadrado
+                pixel = Square(
+                    side_length=(fractal_width / RES),
+                    fill_opacity=1,
+                    stroke_width=0
+                )
+                pixel.set_fill(color)
+                # Posicionarlo en la escena
+                pixel.move_to(mandelbrot_to_manim(x, y))
+                mandelbrot_group.add(pixel)
+
+        # Invertimos verticalmente el mandelbrot
+        # (flip en el eje UP equivaldría a "reflejar" sobre el eje horizontal)
+        mandelbrot_group.flip(UP)
+
+        # Ahora lo desplazamos debajo del diagrama de bifurcación
+        #mandelbrot_group.next_to(bif_axes_group, DOWN, buff=1.0)
+
+        # ------------------------------------------------
+        # 4) Añadir líneas que conecten r (arriba) con c (abajo)
+        # ------------------------------------------------
+        # Supongamos un mapeo lineal: c(r) = -2 + 3r/4
+        # => si r=0 -> c=-2, si r=4 -> c=1
+        # Dibujamos líneas en r_line_values = [0,1,2,3,4], por ejemplo
+        r_line_values = [1, 3, 3.45, 3.85]
+        lines_group = VGroup()
+
+        for rv in r_line_values:
+            # Coordenada X en el diagrama de bifurcación (arriba)
+            top_x = axes_top.coords_to_point(rv, 1.0)  # y=1 (para que baje desde "arriba")
+            # Calculamos c
+            c_val = -2 + 3*rv/4.0
+            # Lo llevamos al mandelbrot "invertido"
+            # Tomamos y=0 (eje real) antes de la inversión
+            # => (c_val, 0) en el plano del fractal
+            # Convertimos a la posición en la escena con la misma función,
+            # y luego aplicamos la inversión que ya hicimos con .flip(UP).
+            # Para no complicarnos, simplemente localizamos el pixel en y=0:
+            bottom_point_before_flip = mandelbrot_to_manim(c_val, 0)
+            # Como ya hemos hecho un flip vertical, la posición en la escena
+            # es la misma. Solo necesitamos el SHIFT que le dimos a mandelbrot_group.
+            # Extraemos la posición final sumando su center:
+            bottom_x = bottom_point_before_flip + mandelbrot_group.get_center() - ORIGIN
+
+            # Creamos la línea
+            line = DashedLine(
+                start=top_x,
+                end=bottom_x,
+                dash_length=0.05,
+                color=YELLOW
+            )
+            lines_group.add(line)
 
-        r_values = np.linspace(0.7, 4.0, 15000)
-        points = VGroup()
+        # ------------------------------------------------
+        # 5) Añadimos todo a la escena
+        # ------------------------------------------------
+        self.play(FadeIn(title))
+        self.wait(0.5)
 
-        for r, x in bifurcation_diagram(r_values, 1000, 100):
-            for i in range(len(r)):
-                points.add(Dot(axes.coords_to_point(r[i], x[i]), radius=0.01, color=WHITE))
+        # Diagrama de bifurcación
+        # self.play(FadeIn(bif_axes_group))
+        # self.play(FadeIn(bif_points, lag_ratio=0.01), run_time=2)
+        # self.wait(0.5)
 
-        self.play(FadeIn(points, lag_ratio=0.01), run_time=2)
-        self.wait()
+        mandelbrot_group.next_to(title, DOWN).set_x(0)
+
+        # Mandelbrot (invertido)
+        self.play(FadeIn(mandelbrot_group, lag_ratio=0.01), run_time=2)
+        self.wait(0.5)
+
+        # Líneas de conexión
+        # self.play(Create(lines_group))
+        # self.wait(2)
+