Fractal De Malthus 2

Que onda chavos me da gusto saludarlos de nuevo y en esta ocasión para continuar con el tema de los fractales, programaremos el fractal conocido como el fractal de Malthus 2, como ya se los había dicho en la vez pasada.

Bien pues rápidamente comencemos. Lo primero será como ya hemos estado acostumbrando hacer será cambiar el color de la Forma. Como ya les había mencionado en ocasiones pasadas esto es opcional, si quieren lo pueden hacer e incluso pueden elegir el color que ustedes deseen, en mi caso yo cambiaré el color de la Forma a color rojo. Inmediatamente después tenemos que colocar un botón sobre la Forma.

Nuestra interfaz debería verse mas o menos de la siguiente manera, dependiendo de lo que hayan elegido ustedes:

Ahora nos vamos a la parte del código la cual será bastante sencilla. Primero nos vamos al archivo H y en la parte de declaraciones privadas declaramos las siguientes variables:


private: // User declarations
        int maxX, maxY;


Luego en la parte de las declaraciones públicas escribimos la definición del método ExtranioConfinador(), el cual es diferente a los que ya hemos utilizado antes a pesar de tener el mismo nombre:


public: // User declarations
        __fastcall TForm1(TComponent* Owner);
        void TForm1::ExtranioConfinador();


Bueno ahora nos vamos a la Forma y en sus respectivos eventos buscamos el evento OnCreate y damos doble clic, luego en él escribimos el siguiente código:



void __fastcall TForm1::FormCreate(TObject *Sender)
{
        maxX = this->ClientWidth;
        maxY = this->ClientHeight;      
}
//---------------------------------------------------------------------------



Es hora pues de codificar el método ExtranioConfinador(), el código que necesitaremos para poder generar el efecto del fractal es el que tenemos a continuación:


void TForm1::ExtranioConfinador()
{
        int i, j, k, l, Color, Contador;
        double PobAnt, PobNueva, X, Y, Razon;
        PobAnt = PobNueva = 0.0;
        Razon = 2.3;
        Y = 0;
        for ( j = 1; j <= 15; j++)
        {
                Color++;
                if ( Color > clWhite )
                        Color = clBlue;
                for ( k = 1; k <= 10; k++ )
                {
                        Contador = 0;
                        Razon = Razon + 0.01;
                        PobAnt = 0.01;
                        for ( i = 1;  i <= 1000; i++)
                        {
                                PobNueva = Razon * ( PobAnt * ( 1 - PobAnt ) );
                                X = PobNueva - PobAnt;
                                this->Canvas->Pixels[(X*maxX/2)+maxX/2][(maxY/2)-(Y*maxY/2)]=(TColor)Color;
                                if( PobAnt == PobNueva )
                                        Contador++;
                                else
                                        Contador = 0;
                                if( Contador > 100 )
                                        i = 10000;
                                PobAnt = PobNueva;
                                Y = X;
                        }
                }
        }
        this->Canvas->TextOutA(10, 10, "Flujo Maltusiano");
}

//---------------------------------------------------------------------------

Ya para terminar damos doble clic en el botón que habíamos colocado sobre la Forma y en el escribimos la llamada el método ExtranioConfinador(), el código es así:


void __fastcall TForm1::Button1Click(TObject *Sender)
{
        this->Repaint();
        ExtranioConfinador();      
}
//---------------------------------------------------------------------------


Y es todo chavos ahora todo lo que tenemos que hacer es compilar y correr nuestra aplicación y aquí tenemos el efecto que se debe de generar:

Bien chavos por esta ocasión fue todo, como pueden ir viendo generar los fractales es algo bastante sencillo y rápido pero también muy interesante debido a los efectos que se van formando. Aun nos quedan unos cuantos por ver, pero eso ya será en otra ocasión. Hasta la vista amigos!.