Conjunto de Mandelbrot

Propósito:

Representar gráficamente el conjunto de Mandelbrot. Este ejercicio permite explorar la aplicación de ecuaciones complejas e iteraciones en la generación de fractales. Además, se utiliza para demostrar cómo se pueden manipular y utilizar las bibliotecas de Java para crear interfaces gráficas de usuario y manejar imágenes. A través de este código, también se puede aprender a organizar y gestionar eficientemente las variables y métodos de las bibliotecas importadas.

El conjunto de Mandelbrot es un conjunto de números complejos que se obtiene al iterar una función cuadrática. En la imagen generada, los puntos que pertenecen al conjunto de Mandelbrot se colorean de negro, mientras que los que no pertenecen se dejan en blanco. La imagen resultante tiene una forma fractal muy característica.

Tiempo: 50 minutos.

Recursos: Java, Internet y Eclipse.

Copiar código
    
        
// Importa las clases necesarias para la interfaz gráfica de usuario y el manejo de imágenes
import java.awt.*;
import javax.swing.JFrame;
import javax.swing.JPanel;



@SuppressWarnings("unused")

public class ConjuntoMandelbrot {

      

@SuppressWarnings("deprecation")

       public static void main(String[] args) {

             // Crea una instancia de la clase Mandelbrot
             JFrame frame = new Mandelbrot();

           // Muestra la ventana
           frame.show();

         }

       }

@SuppressWarnings("serial")

       class Mandelbrot extends JFrame {

         public Mandelbrot() {

           // Establece el título de la ventana
           setTitle("Conjunto de Mandelbrot");

           // Establece el tamaño de la ventana
           setSize(300, 350);

           // Añade un oyente para el evento de cierre de la ventana
           addWindowListener(new WindowAdapter() {

             public void windowClosing(WindowEvent e) {

               //Termina el programa cuando se cierra la ventana
               System.exit(0);

             }

           });     

           // Obtiene el contenedor principal de la ventana
           Container contentPane = getContentPane();

           // Añade el panel de Mandelbrot al contenedor
           contentPane.add(new MandelbrotPanel(), "Center");

         }

       }

@SuppressWarnings("serial")

       class MandelbrotPanel extends JPanel {

         public void paintComponent(Graphics g) {

           // Llama al método original paintComponent
           super.paintComponent(g);

           // Crea una imagen en memoria para dibujar el conjunto de Mandelbrot
           BufferedImage image = new BufferedImage(getWidth(), getHeight(),

               BufferedImage.TYPE_INT_ARGB);

           // Genera el conjunto de Mandelbrot en la imagen
           generate(image);

           // Dibuja la imagen en el panel
           g.drawImage(image, 0, 0, null);

         }   

         public void generate(BufferedImage image) {

           int width = image.getWidth();

           int height = image.getHeight();

           WritableRaster raster = image.getRaster();

           ColorModel model = image.getColorModel();

        

           // Color para los puntos que pertenecen al conjunto de Mandelbrot
           Color nColor = Color.black;

           int argb = nColor.getRGB();

           Object colorData = model.getDataElements(argb, null);

        
           // Itera sobre cada pixel de la imagen
           for (int i = 0; i < width; i++)

             for (int j = 0; j < height; j++) {
               // Calcula las coordenadas complejas correspondientes al pixel
               double Xinicial = XMIN + i * (XMAX - XMIN) / width;
               double Yinicial = YMIN + j * (YMAX - YMIN) / height;

               // Si el punto no escapa al infinito, lo colorea de negro
               if (!escapesToInfinity(Xinicial, Yinicial))
                 raster.setDataElements(i, j, colorData);

             }

         }   

         private boolean escapesToInfinity(double Xinicial, double Yinicial) {

           double Xanterior = 0.0;

           double Yanterior = 0.0;

           double r;

           int iterations = 0;

           do {

             // Calcula el siguiente término de la secuencia
             double Xnueva = Xanterior * Xanterior - Yanterior * Yanterior - Xinicial;

             double Ynueva = 2 * Xanterior * Yanterior - Yinicial;

             Xanterior = Xnueva;

             Yanterior = Ynueva;

             // Calcula la distancia al origen
             r = Math.sqrt((Xnueva * Xnueva) + (Ynueva * Ynueva));

             iterations++;

             // Si se han realizado suficientes iteraciones, considera que el punto no escapa al infinito
             if (iterations == MAX_ITERATIONS)

               return false;

           // Si la distancia al origen es mayor que 2, considera que el punto escapa al infinito
           } while (r <= 2 && r >= -2);

           return true;

         }

         // Define los límites del plano complejo a representar
         private static final double XMAX = 2.0;

         private static final double XMIN = -1.0;    

         private static final double YMAX = 2.0;     

         private static final double YMIN = -2.0;    

         // Define el número máximo de iteraciones a realizar
         private static final int MAX_ITERATIONS = 1000;

       }