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!.
viernes, 6 de abril de 2012
jueves, 5 de abril de 2012
Fractal De Malthus 1
Hola chavos! Espero que anden de lo mejor y yo aquí ando pasando rápidamente para mostrarles otro ejemplo de los fractales por supuesto programado en C++ Builder. En esta ocasión el fractal que programaremos será el conocido como el fractal de Malthus 1.
Bien pues como siempre ya saben que el primer paso que realizo es opcional, si quieren pueden seguirlo y si no pues no hay problema todo funcionará normalmente. Lo primero que haré yo será cambiar el color de la Forma en su propiedad color buscamos el color clTeal y lo elegimos. Ahora colocamos un botón sobre la Forma y eso será todo lo que tenemos que hacer sobre la Forma, la cual nos quedará de la siguiente manera:
Bien ahora nos cambiamos a la parte del editor de código y nos vamos al archivo cabecera del programa, es decir al archivo H y en la parte de declaraciones privadas tecleamos las siguientes variables:
private: // User declarations
int maxX, maxY, MaxGen;
Ahora en la parte de las declaraciones públicas escribimos la siguiente definición del método ExtranioConfinador(), que aunque su nombre es igual al método que utilizamos en el fractal pasado su funcionamiento es completamente diferente:
public: // User declarations
__fastcall TForm1(TComponent* Owner);
void TForm1::ExtranioConfinador();
Bueno ahora nos vamos a la Forma y en sus eventos elegimos el llamado OnCreate y le damos doble clic, ahí tecleamos el siguiente código, que nos servirá para que las siguientes variables tomen un valor cada vez que ejecutemos nuestra aplicación:
void __fastcall TForm1::FormCreate(TObject *Sender)
{
MaxGen = 0x00FF;
maxX = this->ClientWidth;
maxY = this->ClientHeight;
}
//---------------------------------------------------------------------------
Enseguida escribimos el método ExtranioConfinador(), el código que necesitamos para generar el efecto del fractal es el que tenemos a continuación:
void TForm1::ExtranioConfinador()
{
int i, j, k, l, Color, Contador, X, Y;
double PobAnt, PobNueva, Razon;
PobNueva = 0.0;
Razon = 2.3;
Color = clBlack;
for( j = 1; j <= 151; j++ )
{
Color++;
if( Color >= clWhite )
Color = clBlue;
Contador = 0;
Razon += 0.01;
PobAnt = 0.01;
for( i = 1; i <= MaxGen; i++ )
{
PobNueva = Razon * ( PobAnt * ( 1 - PobAnt ) );
X = PobAnt * maxX;
Y = maxY - ( PobNueva * maxY );
this->Canvas->Pixels[X][Y] = (TColor)Color;
if ( PobAnt == PobNueva )
Contador++;
else
Contador = 0;
if ( Contador > 10 )
i = MaxGen;
PobAnt = PobNueva;
}
this->Canvas->TextOutA(10, 10, "Flujo Maltusiano");
Sleep(5);
}
}
//---------------------------------------------------------------------------
Finalmente solo queda escribir la llamada al método en el evento OnClic del botón que habíamos colocado sobre la Forma:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
this->Repaint();
ExtranioConfinador();
}
//---------------------------------------------------------------------------
Y así de fácil fue todo chavos ahora compilamos y corremos nuestra aplicación y si hicimos todo correctamente obtendremos un efecto como el siguiente:
Bueno amigos pues ya hemos visto un montón de fractales diferentes pero aun nos quedan unos cuantos más por mostrar, ya que como les había dicho antes este tema es bastante amplio e interesante. Por hoy eso fue todo chavos nos vemos en la siguiente ocasión para continuar con más de este mismo tema y mostrar otro fractal parecido al de hoy conocido como el fractal de Malthus 2, hasta entonces amigos!!.
Bien pues como siempre ya saben que el primer paso que realizo es opcional, si quieren pueden seguirlo y si no pues no hay problema todo funcionará normalmente. Lo primero que haré yo será cambiar el color de la Forma en su propiedad color buscamos el color clTeal y lo elegimos. Ahora colocamos un botón sobre la Forma y eso será todo lo que tenemos que hacer sobre la Forma, la cual nos quedará de la siguiente manera:
Bien ahora nos cambiamos a la parte del editor de código y nos vamos al archivo cabecera del programa, es decir al archivo H y en la parte de declaraciones privadas tecleamos las siguientes variables:
private: // User declarations
int maxX, maxY, MaxGen;
Ahora en la parte de las declaraciones públicas escribimos la siguiente definición del método ExtranioConfinador(), que aunque su nombre es igual al método que utilizamos en el fractal pasado su funcionamiento es completamente diferente:
public: // User declarations
__fastcall TForm1(TComponent* Owner);
void TForm1::ExtranioConfinador();
Bueno ahora nos vamos a la Forma y en sus eventos elegimos el llamado OnCreate y le damos doble clic, ahí tecleamos el siguiente código, que nos servirá para que las siguientes variables tomen un valor cada vez que ejecutemos nuestra aplicación:
void __fastcall TForm1::FormCreate(TObject *Sender)
{
MaxGen = 0x00FF;
maxX = this->ClientWidth;
maxY = this->ClientHeight;
}
//---------------------------------------------------------------------------
Enseguida escribimos el método ExtranioConfinador(), el código que necesitamos para generar el efecto del fractal es el que tenemos a continuación:
void TForm1::ExtranioConfinador()
{
int i, j, k, l, Color, Contador, X, Y;
double PobAnt, PobNueva, Razon;
PobNueva = 0.0;
Razon = 2.3;
Color = clBlack;
for( j = 1; j <= 151; j++ )
{
Color++;
if( Color >= clWhite )
Color = clBlue;
Contador = 0;
Razon += 0.01;
PobAnt = 0.01;
for( i = 1; i <= MaxGen; i++ )
{
PobNueva = Razon * ( PobAnt * ( 1 - PobAnt ) );
X = PobAnt * maxX;
Y = maxY - ( PobNueva * maxY );
this->Canvas->Pixels[X][Y] = (TColor)Color;
if ( PobAnt == PobNueva )
Contador++;
else
Contador = 0;
if ( Contador > 10 )
i = MaxGen;
PobAnt = PobNueva;
}
this->Canvas->TextOutA(10, 10, "Flujo Maltusiano");
Sleep(5);
}
}
//---------------------------------------------------------------------------
Finalmente solo queda escribir la llamada al método en el evento OnClic del botón que habíamos colocado sobre la Forma:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
this->Repaint();
ExtranioConfinador();
}
//---------------------------------------------------------------------------
Y así de fácil fue todo chavos ahora compilamos y corremos nuestra aplicación y si hicimos todo correctamente obtendremos un efecto como el siguiente:
Bueno amigos pues ya hemos visto un montón de fractales diferentes pero aun nos quedan unos cuantos más por mostrar, ya que como les había dicho antes este tema es bastante amplio e interesante. Por hoy eso fue todo chavos nos vemos en la siguiente ocasión para continuar con más de este mismo tema y mostrar otro fractal parecido al de hoy conocido como el fractal de Malthus 2, hasta entonces amigos!!.
miércoles, 4 de abril de 2012
Fractal De Henon
Hola de nueva cuenta amigos! Aquí me encuentro otra vez para continuar con más aplicaciones en C++ Builder. En este momento estamos analizando el tema de los fractales y en esta ocasión programaremos uno más el cual es llamado el fractal de Henon.
Para realizar esto lo primero que haremos será cambiar el colo de la Forma a verde (como siempre ya saben que este paso es opcional). Después todo lo que necesitaremos será colocar un botón sobre la Forma. Entonces procedemos con la parte del código, por lo pronto nuestra Forma debe quedar mas o menos así:
Ahora nos vamos al archivo H de nuestra aplicación y en la parte privada declaramos las siguientes variables:
private: // User declarations
int maxX, maxY;
double EscalaX, EscalaY, DespX, DespY;
Luego en la parte pública escribimos la definición del método que utilizaremos para generar el fractal:
public: // User declarations
__fastcall TForm1(TComponent* Owner);
void TForm1::ExtranioConfinador();
Bueno ahora abrimos el evento OnCreate de la Forma y en él escribimos el siguiente código para que las variables maxX y maxY carguen los valores apenas corramos nuestra aplicación:
void __fastcall TForm1::FormCreate(TObject *Sender)
{
maxX=this->ClientWidth;
maxY=this->ClientHeight;
}
//---------------------------------------------------------------------------
Enseguida escribimos el código del método anteriormente definido, es decir, el método ExtranioConfinador(), este es el codigo:
void TForm1::ExtranioConfinador()
{
int a,i,PosX,PosY, Color;
double Xant,Xnuevo,Yant,Ynuevo;
HDC hdc;
Xant = Xnuevo = Yant = Ynuevo = 0;
for(Color=1; Color<=15; Color++)
for(i=1; i<=0x02ff; i++)
{
Sleep(1);
Xnuevo = Yant + 1 - (1.4*Xant *Xant);
Ynuevo = 0.3 * Xant;
PosX = ( Xnuevo * maxX / 3 * EscalaX ) + maxX / 2 + DespX;
PosY = ( Ynuevo * maxY * EscalaY ) + maxY / 2 + DespY;
if(( PosX>=0)&&(PosX<=maxX)&&(PosY>=0)&&(PosY<=maxY))
this->Canvas->Pixels[PosX][PosY]=(TColor)Color;
Xant=Xnuevo;
Yant=Ynuevo;
}
this->Canvas->TextOutA(10,110,"CONFINADOR HENON");
this->Canvas->TextOutA(10,130,EscalaX);
this->Canvas->TextOutA(10,150,EscalaY);
this->Canvas->TextOutA(10,170,DespX);
this->Canvas->TextOutA(10,190,DespY);
}
//---------------------------------------------------------------------------
Para realizar esto lo primero que haremos será cambiar el colo de la Forma a verde (como siempre ya saben que este paso es opcional). Después todo lo que necesitaremos será colocar un botón sobre la Forma. Entonces procedemos con la parte del código, por lo pronto nuestra Forma debe quedar mas o menos así:
Ahora nos vamos al archivo H de nuestra aplicación y en la parte privada declaramos las siguientes variables:
private: // User declarations
int maxX, maxY;
double EscalaX, EscalaY, DespX, DespY;
Luego en la parte pública escribimos la definición del método que utilizaremos para generar el fractal:
public: // User declarations
__fastcall TForm1(TComponent* Owner);
void TForm1::ExtranioConfinador();
Bueno ahora abrimos el evento OnCreate de la Forma y en él escribimos el siguiente código para que las variables maxX y maxY carguen los valores apenas corramos nuestra aplicación:
void __fastcall TForm1::FormCreate(TObject *Sender)
{
maxX=this->ClientWidth;
maxY=this->ClientHeight;
}
//---------------------------------------------------------------------------
Enseguida escribimos el código del método anteriormente definido, es decir, el método ExtranioConfinador(), este es el codigo:
void TForm1::ExtranioConfinador()
{
int a,i,PosX,PosY, Color;
double Xant,Xnuevo,Yant,Ynuevo;
HDC hdc;
Xant = Xnuevo = Yant = Ynuevo = 0;
for(Color=1; Color<=15; Color++)
for(i=1; i<=0x02ff; i++)
{
Sleep(1);
Xnuevo = Yant + 1 - (1.4*Xant *Xant);
Ynuevo = 0.3 * Xant;
PosX = ( Xnuevo * maxX / 3 * EscalaX ) + maxX / 2 + DespX;
PosY = ( Ynuevo * maxY * EscalaY ) + maxY / 2 + DespY;
if(( PosX>=0)&&(PosX<=maxX)&&(PosY>=0)&&(PosY<=maxY))
this->Canvas->Pixels[PosX][PosY]=(TColor)Color;
Xant=Xnuevo;
Yant=Ynuevo;
}
this->Canvas->TextOutA(10,110,"CONFINADOR HENON");
this->Canvas->TextOutA(10,130,EscalaX);
this->Canvas->TextOutA(10,150,EscalaY);
this->Canvas->TextOutA(10,170,DespX);
this->Canvas->TextOutA(10,190,DespY);
}
//---------------------------------------------------------------------------
Bien para terminar solo damos doble clic en el botón que habíamos colocado sobre la Forma y en el evento OnClic que se abre escribimos el código que tenemos a continuación:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
this->Repaint();
EscalaX=1;
EscalaY=1;
DespX=0;
DespY=0;
ExtranioConfinador();
}
//---------------------------------------------------------------------------
Eso es todos chavos ahora solo queda compilar y correr nuestra aplicación y nos generará el efecto de la curva de Henon además nos desplegará en pantalla los valores de la escala en X, la escala en Y, así como los desplazamientos en X y en Y. Nuestra aplicación quedará de la siguiente manera:
Eso es todo por hoy amigos nos vemos en la próxima con un ejemplo más de los diferentes fractales que podemos generar mediante programación, espero que ya se sientan todos unos expertos en el C++ Builder y sino pues no queda de otra que seguir practicando. Hasta la vista amigos!.
martes, 3 de abril de 2012
Fractal De Mandelbrot
Hola amigos! En esta ocasión vamos a continuar rápidamente con el tema de los fractales y programaremos otro diferente a los que ya hemos hecho anteriormente, hoy le toca el turno al fractal de Mandelbrot.
Bien pues para comenzar lo primero es que tenemos que pintar la Forma de color (esto es opcional), damos clic en la propiedad Color de la forma y elegimos clNavy. Ahora colocamos un botón sobre la forma y eso es todo lo que necesitamos para comenzar a programar. Nuestra forma debería verse mas o menos de la siguiente manera:
Con la interfaz ya lista comenzamos entonces con la programación del fractal de Mandelbrot. Primero nos vamos a el archivo H y en la parte pública declaramos las siguientes variables que utilizaremos más adelante:
int maxX, maxY, Limite, i, j, Pasos, Terminar;
double PasoX, PasoY, PosX, PosY, OrigX, OrigY, DimX, DimY, IterX, IterY, TempX;
Esto será bastante sencillo y rápido chavos ahora nos cambiamos al archivo .cpp, o nos vamos a la Forma y damos doble clic en el botón para abrir su evento OnClic y ahí escribimos el siguiente código que será el que nos formará el efecto de Mandelbrot:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
maxX = Form1->ClientWidth;
maxY = Form1->ClientHeight;
Limite = 100;
OrigX = -2.0;
OrigY = -1.25;
DimX = 0.5;
DimY = 1.25;
PasoX = ( DimX - OrigX ) / maxX;
PasoY = ( DimY - OrigY ) / maxY;
for ( i = 0; i <= maxX; i++)
for ( j = 0; j <= maxY; j++)
{
PosX = OrigX + i * PasoX;
PosY = OrigY + j * PasoY;
IterX = 0.0;
IterY = 0.0;
Terminar = Pasos = 0;
while ( !Terminar )
{
TempX = ( IterX * IterX ) - ( IterY * IterY ) + PosX;
IterY = 2 * ( IterX * IterY ) + PosY;
IterX = TempX;
Pasos++;
if ( hypot( fabs(IterX), fabs(IterY)) >= 2.0)
Terminar++;
if ( Pasos >= Limite )
Terminar++;
}
if ( Pasos < Limite )
Canvas->Pixels[i][j] = (TColor)Pasos;
}
}
//---------------------------------------------------------------------------
Y pues aunque no lo crean es todo chavos, ahora solo tenemos que compilar nuestra programa y correrlo para ver su funcionamiento y si todo salió bien nuestra aplicación debería verse así:
Y por hoy eso fue todo amigos nos vemos la próxima ocasión en la que programaremos otro fractal más para que sigan viendo las diferentes opciones que tenemos en este amplio tema. Hasta la vista chavos!.
Bien pues para comenzar lo primero es que tenemos que pintar la Forma de color (esto es opcional), damos clic en la propiedad Color de la forma y elegimos clNavy. Ahora colocamos un botón sobre la forma y eso es todo lo que necesitamos para comenzar a programar. Nuestra forma debería verse mas o menos de la siguiente manera:
Con la interfaz ya lista comenzamos entonces con la programación del fractal de Mandelbrot. Primero nos vamos a el archivo H y en la parte pública declaramos las siguientes variables que utilizaremos más adelante:
int maxX, maxY, Limite, i, j, Pasos, Terminar;
double PasoX, PasoY, PosX, PosY, OrigX, OrigY, DimX, DimY, IterX, IterY, TempX;
Esto será bastante sencillo y rápido chavos ahora nos cambiamos al archivo .cpp, o nos vamos a la Forma y damos doble clic en el botón para abrir su evento OnClic y ahí escribimos el siguiente código que será el que nos formará el efecto de Mandelbrot:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
maxX = Form1->ClientWidth;
maxY = Form1->ClientHeight;
Limite = 100;
OrigX = -2.0;
OrigY = -1.25;
DimX = 0.5;
DimY = 1.25;
PasoX = ( DimX - OrigX ) / maxX;
PasoY = ( DimY - OrigY ) / maxY;
for ( i = 0; i <= maxX; i++)
for ( j = 0; j <= maxY; j++)
{
PosX = OrigX + i * PasoX;
PosY = OrigY + j * PasoY;
IterX = 0.0;
IterY = 0.0;
Terminar = Pasos = 0;
while ( !Terminar )
{
TempX = ( IterX * IterX ) - ( IterY * IterY ) + PosX;
IterY = 2 * ( IterX * IterY ) + PosY;
IterX = TempX;
Pasos++;
if ( hypot( fabs(IterX), fabs(IterY)) >= 2.0)
Terminar++;
if ( Pasos >= Limite )
Terminar++;
}
if ( Pasos < Limite )
Canvas->Pixels[i][j] = (TColor)Pasos;
}
}
//---------------------------------------------------------------------------
Y pues aunque no lo crean es todo chavos, ahora solo tenemos que compilar nuestra programa y correrlo para ver su funcionamiento y si todo salió bien nuestra aplicación debería verse así:
Y por hoy eso fue todo amigos nos vemos la próxima ocasión en la que programaremos otro fractal más para que sigan viendo las diferentes opciones que tenemos en este amplio tema. Hasta la vista chavos!.
lunes, 2 de abril de 2012
Fractal Del Dragón
Hola de nueva cuenta amigos! Es hora de continuar practicando con el C++ Builder, en esta ocasión programaremos otro fractal como el de la vez anterior pero este genera un efecto diferente y es conocido como el fractal del dragón.
Bien pues para empezar primero cambiamos el color de la Forma a negro, y colocamos los siguientes componentes:
-1 botón
-1 Edit (con un valor inicial de 2)
-1 Edit (con un valor inicial de 12)
-1 UpDown (con un valor mínimo de 1 y máximo de 10, asociado con el Edit1)
-1 UpDown (con un valor mínimo de 1 y máximo de 13, asociado con el Edit2)
La forma en mi caso queda de la siguiente manera:
Ahora abrimos el archivo H y en la parte privada declaramos las siguientes variables:
private: // User declarations
int Paso, Signo, EjeX[4098], EjeY[4098], x1, y1, x2, y2;
Y en la parte pública declaramos la definición de los métodos que utilizaremos:
public: // User declarations
__fastcall TForm1(TComponent* Owner);
void TForm1::GenerarDragon();
Bueno pues enseguida declaramos el método GenerarDragon(), ahora en el archivo .cpp:
void TForm1::GenerarDragon()
{
int i, j, dx, dy;
j = Paso / 2;
for(i = 1; i <= 4096; i += Paso)
{
dx = EjeX[Paso+i] - EjeX[i];
dy = EjeY[Paso+i] - EjeY[i];
Signo *= -1;
EjeX[i + j] = EjeX[i] + (dx + (dy * Signo)) / Edit1->Text.ToInt();
EjeY[i + j] = EjeY[i] + (dy - (dx * Signo)) / Edit1->Text.ToInt();
this->Canvas->MoveTo(EjeX[i],EjeY[i]);
this->Canvas->LineTo(EjeX[i+j],EjeY[i+j]);
this->Canvas->MoveTo(EjeX[i+j],EjeY[i+j]);
this->Canvas->LineTo(EjeX[i+Paso],EjeY[i+Paso]);
Sleep(1);
}
}
//--------------------------------------------------------------------------
Ahora abrimos el Button1 y escribimos el código que tenemos a continuación:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Paso = 4096;
Signo = -1;
EjeX[1] = this->ClientWidth / 4;
EjeX[4097] = 3 * this->ClientWidth / 4;
EjeY[1] = EjeY[4097] = 2 * this->ClientHeight / 3;
this->Canvas->Pen->Color = clRed;
this->Canvas->MoveTo(EjeX[1],EjeY[1]);
this->Canvas->LineTo(EjeX[4097],EjeY[4097]);
for(int i = 1; i <= Edit2->Text.ToInt(); i++)
{
this->Repaint();
GenerarDragon();
Paso /= 2;
}
}
//---------------------------------------------------------------------------
Ahora abrimos en evento OnPaint de la Forma y escribimos la siguiente línea:
void __fastcall TForm1::FormResize(TObject *Sender)
{
Invalidate();
}
//---------------------------------------------------------------------------
Y pues eso es todo chavos ahora solo queda compilar nuestra aplicación y correrla para ver como funciona. Pueden mover los valores de los Edits para ver los diferentes efectos que se forman, el primero afectará la forma que tendrá el fractal al formarse y el segundo es el número de iteraciones que realizará la aplicación para formar el fractal. El resultado final es el siguiente:
Por hoy eso fue todo amigos nos vemos en la siguiente ocasión para seguir con más de este tema de los fractales que es bastante amplio y ay mucha variedad de ellos. Nos vemos chavos!.
Bien pues para empezar primero cambiamos el color de la Forma a negro, y colocamos los siguientes componentes:
-1 botón
-1 Edit (con un valor inicial de 2)
-1 Edit (con un valor inicial de 12)
-1 UpDown (con un valor mínimo de 1 y máximo de 10, asociado con el Edit1)
-1 UpDown (con un valor mínimo de 1 y máximo de 13, asociado con el Edit2)
La forma en mi caso queda de la siguiente manera:
Ahora abrimos el archivo H y en la parte privada declaramos las siguientes variables:
private: // User declarations
int Paso, Signo, EjeX[4098], EjeY[4098], x1, y1, x2, y2;
Y en la parte pública declaramos la definición de los métodos que utilizaremos:
public: // User declarations
__fastcall TForm1(TComponent* Owner);
void TForm1::GenerarDragon();
Bueno pues enseguida declaramos el método GenerarDragon(), ahora en el archivo .cpp:
void TForm1::GenerarDragon()
{
int i, j, dx, dy;
j = Paso / 2;
for(i = 1; i <= 4096; i += Paso)
{
dx = EjeX[Paso+i] - EjeX[i];
dy = EjeY[Paso+i] - EjeY[i];
Signo *= -1;
EjeX[i + j] = EjeX[i] + (dx + (dy * Signo)) / Edit1->Text.ToInt();
EjeY[i + j] = EjeY[i] + (dy - (dx * Signo)) / Edit1->Text.ToInt();
this->Canvas->MoveTo(EjeX[i],EjeY[i]);
this->Canvas->LineTo(EjeX[i+j],EjeY[i+j]);
this->Canvas->MoveTo(EjeX[i+j],EjeY[i+j]);
this->Canvas->LineTo(EjeX[i+Paso],EjeY[i+Paso]);
Sleep(1);
}
}
//--------------------------------------------------------------------------
Ahora abrimos el Button1 y escribimos el código que tenemos a continuación:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Paso = 4096;
Signo = -1;
EjeX[1] = this->ClientWidth / 4;
EjeX[4097] = 3 * this->ClientWidth / 4;
EjeY[1] = EjeY[4097] = 2 * this->ClientHeight / 3;
this->Canvas->Pen->Color = clRed;
this->Canvas->MoveTo(EjeX[1],EjeY[1]);
this->Canvas->LineTo(EjeX[4097],EjeY[4097]);
for(int i = 1; i <= Edit2->Text.ToInt(); i++)
{
this->Repaint();
GenerarDragon();
Paso /= 2;
}
}
//---------------------------------------------------------------------------
Ahora abrimos en evento OnPaint de la Forma y escribimos la siguiente línea:
void __fastcall TForm1::FormResize(TObject *Sender)
{
Invalidate();
}
//---------------------------------------------------------------------------
Y pues eso es todo chavos ahora solo queda compilar nuestra aplicación y correrla para ver como funciona. Pueden mover los valores de los Edits para ver los diferentes efectos que se forman, el primero afectará la forma que tendrá el fractal al formarse y el segundo es el número de iteraciones que realizará la aplicación para formar el fractal. El resultado final es el siguiente:
domingo, 1 de abril de 2012
Fractal De Newton-Raphson
Hola a todos amigos!! Después de tanto tiempo de no andar por aquí les pido una disculpa y es hora de que volvamos a seguir con las prácticas de aplicaciones gráficas en C++ Builder. Bueno en esta ocasión empezaremos con le tema de los fractales. Si no sabemos lo que son los fractales podemos seguir el siguiente enlace y nuestra buena amiga doña Wikipedia nos lo dirá:
http://es.wikipedia.org/wiki/Fractal
El fractal que programaremos hoy será el conocido como Newton-Raphson. Lo que haremos hoy será un poco diferente a lo que hacemos regularmente ya que esta vez no utilizaremos la Forma que nos da el C++ Builder sino que llamaremos directo a Windows para que nos cree una al tamaño que nosotros deseemos etc.
Bueno pues empezamos por crear una nueva aplicación en C++ Builder y luego nos vamos al menú "Project" luego al sub-menú "Remove From Project" y en la ventana que se abre seleccionamos la opción "Unit1.cpp" y le damos en OK. Esto nos eliminará la Forma ahora abrimos el menú "View" y después el sub-menú "Project Manager" y en la ventana damos doble clic en "Project1.cpp". Una vez que se nos haya abierto el editor de código borramos todo el código que haya escrito y escribimos todo lo siguiente:
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
//--- Declaración de funciones del programa ------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int );
LRESULT CALLBACK WndProc( HWND, UINT, WPARAM, LPARAM );
void CrearPaleta(void);
//--- Declaración de variables del programa ------------------------------
char WindowName[] = "Ventana de Windows";
char WindowTitle[] = "Fractal de Newton-Raphson";
BYTE ColorRGB[256][3];
void CrearPaleta(void)
{
int i;
for (i=0; i<256; i++)
{
if (i<64)
{
ColorRGB[i][0] = 192 + i;
ColorRGB[i][1] = 0;
ColorRGB[i][2] = 0;
}
else if ((i>63) && (i<128))
{
ColorRGB[i][0] = 0;
ColorRGB[i][1] = (192 + i)-64;
ColorRGB[i][2] = 0;
}
else if ((i>127)&&(i<192))
{
ColorRGB[i][0] = 0;
ColorRGB[i][1] = 0;
ColorRGB[i][2] = (192 + i)-128;
}
}
}
//=== Función principal WinMain() ========================================
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow )
{
HWND hwnd; // handle a la ventana ppal.
MSG msg; // estructura de mensaje
WNDCLASSEX wcx; // estructura de la ventana
// Definimos la estructura de clase de ventana (campos):
wcx.cbSize = sizeof( WNDCLASSEX ); // tamaño de la estructura
wcx.style = CS_HREDRAW | CS_VREDRAW; // valores más usuales
wcx.lpfnWndProc = WndProc; // función de ventana (Wnd)
wcx.cbClsExtra = 0;
wcx.cbWndExtra = 0; // informaciones extra
wcx.hInstance = hInstance; // instancia actual
// icono, cursor, fondo e icono pequeño de la clase de ventana:
wcx.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
wcx.hbrBackground = (HBRUSH) GetStockObject( WHITE_BRUSH );
wcx.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
wcx.lpszMenuName = NULL; // nombre del menú
wcx.lpszClassName = WindowName; // nombre de la ventana
// Registramos la clase de ventana ya preparada:
if( !RegisterClassEx( &wcx ) )
return( FALSE ); // en caso de error, salir
// Creamos la ventana con CreateWindowEx():
hwnd = CreateWindowEx(
WS_EX_OVERLAPPEDWINDOW, // estilo extendido
WindowName, // nombre de la ventana
WindowTitle, // título de la ventana
WS_OVERLAPPEDWINDOW, // estilo de ventana
CW_USEDEFAULT, CW_USEDEFAULT, // Posición (x,y) en pantalla
400, 400, // ancho y alto de la ventana
NULL, NULL, // ventana padre e hija+menú
hInstance, // instancia actual
NULL // no hay más información
);
// Comprobamos la creación de la ventana:
if( !hwnd )
return( FALSE ); // en caso de error, salir
// Hacemos visible la ventana y la actualizamos:
ShowWindow( hwnd, nCmdShow );
UpdateWindow( hwnd );
// Bucle de mensajes, envía los mensajes hacia WndProc
while( GetMessage( &msg, NULL, 0, 0 ) )
{
TranslateMessage( &msg ); // convertimos el mensaje
DispatchMessage( &msg ); // devolvemos el control a w95
}
// devolvemos el valor recibido por PostQuitMessage().
return( msg.wParam );
}
//=== Función del procedimiento de ventana WndProc() =====================
LRESULT CALLBACK WndProc( HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam )
{
HDC hdc;
PAINTSTRUCT ps;
RECT rect;
BYTE R, G, B;
double deltax, deltay, x, y, tmp, xx, yy, d;
float xmin = -2.0, ymin=-2.0, xmax=2.0, ymax=2.0;
int maxiter = 2048;
int maxcol, maxrow;
int color, row, col, count;
switch( message )
{
// mensaje producido en la creación de la ventana
case WM_CREATE:
break;
//dibuja el fractal de Newton-Raphson
case WM_PAINT:
CrearPaleta();
hdc = BeginPaint( hwnd, &ps );
GetClientRect(hwnd, &rect);
maxcol = rect.right - rect.left ;
maxrow = rect.bottom - rect.top;
deltax = (xmax - xmin)/maxcol;
deltay = (ymax - ymin)/maxrow;
for (col=0; col<=maxcol; col++)
{
for (row=0; row<=maxrow; row++)
{
x = xmin + col * deltax;
y = ymin + row * deltay;
count=0;
while (count<maxiter)
{
xx = x*x;
yy = y*y;
d = 3.0*((xx - yy)*(xx - yy) + 4.0*xx*yy);
if (d == 0.0)
d = 0.000001;
tmp=x;
x = (2.0/3.0)*x + (xx - yy)/d;
y = (2.0/3.0)*y - 2.0*tmp*y/d;
count+=1;
}
if (x>0.0)
color = count%64;
else
{
if ((x<-0.3) && (y>0.0))
color = (count%64) + 64;
else
color = (count%64) + 128;
}
R=ColorRGB[color][0];
G=ColorRGB[color][1];
B=ColorRGB[color][2];
SetPixel(hdc, col, row, RGB(R,G,B));
}
}
EndPaint( hwnd, &ps );
break;
// mensaje producido al cerrar la ventana
case WM_DESTROY:
PostQuitMessage( 0 );
break;
// resto de mensajes, dar una respuesta estándar.
default:
return( DefWindowProc( hwnd, message, wParam, lParam ) );
}
return(0);
}
//=== Fin del archivo ====================================================
Ahora compilamos y corremos nuestra aplicación y obtendremos nuestro fractal resultante:
Y bueno amigos por esta ocasión eso fue todo nos vemos más adelante para continuar y ver un poco más de fractales ya que son muy interesantes. Hasta la próxima!!.
http://es.wikipedia.org/wiki/Fractal
El fractal que programaremos hoy será el conocido como Newton-Raphson. Lo que haremos hoy será un poco diferente a lo que hacemos regularmente ya que esta vez no utilizaremos la Forma que nos da el C++ Builder sino que llamaremos directo a Windows para que nos cree una al tamaño que nosotros deseemos etc.
Bueno pues empezamos por crear una nueva aplicación en C++ Builder y luego nos vamos al menú "Project" luego al sub-menú "Remove From Project" y en la ventana que se abre seleccionamos la opción "Unit1.cpp" y le damos en OK. Esto nos eliminará la Forma ahora abrimos el menú "View" y después el sub-menú "Project Manager" y en la ventana damos doble clic en "Project1.cpp". Una vez que se nos haya abierto el editor de código borramos todo el código que haya escrito y escribimos todo lo siguiente:
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
//--- Declaración de funciones del programa ------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int );
LRESULT CALLBACK WndProc( HWND, UINT, WPARAM, LPARAM );
void CrearPaleta(void);
//--- Declaración de variables del programa ------------------------------
char WindowName[] = "Ventana de Windows";
char WindowTitle[] = "Fractal de Newton-Raphson";
BYTE ColorRGB[256][3];
void CrearPaleta(void)
{
int i;
for (i=0; i<256; i++)
{
if (i<64)
{
ColorRGB[i][0] = 192 + i;
ColorRGB[i][1] = 0;
ColorRGB[i][2] = 0;
}
else if ((i>63) && (i<128))
{
ColorRGB[i][0] = 0;
ColorRGB[i][1] = (192 + i)-64;
ColorRGB[i][2] = 0;
}
else if ((i>127)&&(i<192))
{
ColorRGB[i][0] = 0;
ColorRGB[i][1] = 0;
ColorRGB[i][2] = (192 + i)-128;
}
}
}
//=== Función principal WinMain() ========================================
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow )
{
HWND hwnd; // handle a la ventana ppal.
MSG msg; // estructura de mensaje
WNDCLASSEX wcx; // estructura de la ventana
// Definimos la estructura de clase de ventana (campos):
wcx.cbSize = sizeof( WNDCLASSEX ); // tamaño de la estructura
wcx.style = CS_HREDRAW | CS_VREDRAW; // valores más usuales
wcx.lpfnWndProc = WndProc; // función de ventana (Wnd)
wcx.cbClsExtra = 0;
wcx.cbWndExtra = 0; // informaciones extra
wcx.hInstance = hInstance; // instancia actual
// icono, cursor, fondo e icono pequeño de la clase de ventana:
wcx.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
wcx.hbrBackground = (HBRUSH) GetStockObject( WHITE_BRUSH );
wcx.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
wcx.lpszMenuName = NULL; // nombre del menú
wcx.lpszClassName = WindowName; // nombre de la ventana
// Registramos la clase de ventana ya preparada:
if( !RegisterClassEx( &wcx ) )
return( FALSE ); // en caso de error, salir
// Creamos la ventana con CreateWindowEx():
hwnd = CreateWindowEx(
WS_EX_OVERLAPPEDWINDOW, // estilo extendido
WindowName, // nombre de la ventana
WindowTitle, // título de la ventana
WS_OVERLAPPEDWINDOW, // estilo de ventana
CW_USEDEFAULT, CW_USEDEFAULT, // Posición (x,y) en pantalla
400, 400, // ancho y alto de la ventana
NULL, NULL, // ventana padre e hija+menú
hInstance, // instancia actual
NULL // no hay más información
);
// Comprobamos la creación de la ventana:
if( !hwnd )
return( FALSE ); // en caso de error, salir
// Hacemos visible la ventana y la actualizamos:
ShowWindow( hwnd, nCmdShow );
UpdateWindow( hwnd );
// Bucle de mensajes, envía los mensajes hacia WndProc
while( GetMessage( &msg, NULL, 0, 0 ) )
{
TranslateMessage( &msg ); // convertimos el mensaje
DispatchMessage( &msg ); // devolvemos el control a w95
}
// devolvemos el valor recibido por PostQuitMessage().
return( msg.wParam );
}
//=== Función del procedimiento de ventana WndProc() =====================
LRESULT CALLBACK WndProc( HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam )
{
HDC hdc;
PAINTSTRUCT ps;
RECT rect;
BYTE R, G, B;
double deltax, deltay, x, y, tmp, xx, yy, d;
float xmin = -2.0, ymin=-2.0, xmax=2.0, ymax=2.0;
int maxiter = 2048;
int maxcol, maxrow;
int color, row, col, count;
switch( message )
{
// mensaje producido en la creación de la ventana
case WM_CREATE:
break;
//dibuja el fractal de Newton-Raphson
case WM_PAINT:
CrearPaleta();
hdc = BeginPaint( hwnd, &ps );
GetClientRect(hwnd, &rect);
maxcol = rect.right - rect.left ;
maxrow = rect.bottom - rect.top;
deltax = (xmax - xmin)/maxcol;
deltay = (ymax - ymin)/maxrow;
for (col=0; col<=maxcol; col++)
{
for (row=0; row<=maxrow; row++)
{
x = xmin + col * deltax;
y = ymin + row * deltay;
count=0;
while (count<maxiter)
{
xx = x*x;
yy = y*y;
d = 3.0*((xx - yy)*(xx - yy) + 4.0*xx*yy);
if (d == 0.0)
d = 0.000001;
tmp=x;
x = (2.0/3.0)*x + (xx - yy)/d;
y = (2.0/3.0)*y - 2.0*tmp*y/d;
count+=1;
}
if (x>0.0)
color = count%64;
else
{
if ((x<-0.3) && (y>0.0))
color = (count%64) + 64;
else
color = (count%64) + 128;
}
R=ColorRGB[color][0];
G=ColorRGB[color][1];
B=ColorRGB[color][2];
SetPixel(hdc, col, row, RGB(R,G,B));
}
}
EndPaint( hwnd, &ps );
break;
// mensaje producido al cerrar la ventana
case WM_DESTROY:
PostQuitMessage( 0 );
break;
// resto de mensajes, dar una respuesta estándar.
default:
return( DefWindowProc( hwnd, message, wParam, lParam ) );
}
return(0);
}
//=== Fin del archivo ====================================================
Ahora compilamos y corremos nuestra aplicación y obtendremos nuestro fractal resultante:
Y bueno amigos por esta ocasión eso fue todo nos vemos más adelante para continuar y ver un poco más de fractales ya que son muy interesantes. Hasta la próxima!!.
lunes, 5 de marzo de 2012
Manipulación Y Manejo De Pixeles De Bitmap
Hola amigos! En esta ocasión aprenderemos algo muy útil y que nos hará aprender mucho. En nuestra aplicación que realizaremos en esta ocasión aprenderemos como manipular los pixeles de una imágen bitmap, aprenderemos a tomar los pixeles de una imágen personal que cargaremos en el programa y ponerla de cabeza, acostada, cambiar todas las tonalidades por un solo color, y también aprenderemos como hacer zoom a un área en específico de la imágen utilizando la función CopyRect.
Bueno pues comenzamos agregando los componentes que necesitamos en la Forma, los cuales listamos a continuación:
-1 ComboBox
-2 Image (Del mismo tamaño)
-1 Label
-7 Botones
-1 OpenPictureDialog
La Forma debe quedar de la siguiente manera, en mi caso con la imágen del dragón ya cargada en el Image1:
Ahora configuraremos varios de los componentes. El primero de ellos es el Image1, en su propiedad Picture cargamos la imágen de tipo bitmap que deseemos, en mi caso cargo la imágen de un dragón (yo he descargado varias y les recomiendo hacer lo mismo para tener variedad de imágenes y seleccionar otra cuando queramos). Luego en el ComboBox1 en su propiedad Items agregamos los siguientes:
*AND
*OR
*XOR
*NOT
Ahora vamos al archivo H y en la parte de Private declaramos las siguientes variables:
private: // User declarations
int color, left, top, right, bottom;
Y en la parte Public declaramos los métodos Dibujar() y Zoom() que utilizaremos más delante:
public: // User declarations
__fastcall TForm1(TComponent* Owner);
void TForm1::Dibujar();
void TForm1::Zoom();
Bien pues ahora comenzaremos con la codificación. Primero en el evento de creación del TForm1() agregamos la siguiente línea de código para indicar que al correr la aplicación estará seleccionada la primera opción en el ComboBox:
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
ComboBox1->ItemIndex = 0;
}
//---------------------------------------------------------------------------
Antes de todo abrimos el evento OnCreate de la Forma y escribimos el código siguiente que nos ayudará a reducir el parpadeo:
void __fastcall TForm1::FormCreate(TObject *Sender)
{
Form1->Refresh();
this->DoubleBuffered=true;
}
//---------------------------------------------------------------------------
Después, primero definimos los dos métodos que habíamos declarado anteriormente ya que los utilizaremos más adelante. Primero el método Dibujar():
void TForm1::Dibujar()
{
Refresh();
Form1->Canvas->DrawFocusRect(Rect(left+Image1->Left,top+Image1->Top,right+Image1->Left,bottom+Image1->Top));
}
//---------------------------------------------------------------------------
Después el método Zoom():
void TForm1::Zoom()
{
Graphics::TBitmap *Bitmap;
TRect rect1, rect2;
rect1 = Rect(left,top,right,bottom);
rect2 = Rect(430,50,750,390);
Bitmap=Image1->Picture->Bitmap;
Form1->Canvas->CopyRect(rect2, Bitmap->Canvas, rect1);
}
//---------------------------------------------------------------------------
Ahora escribiremos el botón que dice rojo, el cual dependiendo de la opción que esté seleccionada en el ComboBox realizará una operación de "&", "|", "!" ó "^" con el número hexadecimal "0x0000ff" para cambiar todos los colores del bitmap por tonalidades de color rojo:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
switch(ComboBox1->ItemIndex)
{
case 0:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color&0x0000ff;
}
break;
case 1:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color|0x0000ff;
}
break;
case 2:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color^0x0000ff;
}
break;
case 3:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = ~(TColor)color;
}
break;
}
}
//---------------------------------------------------------------------------
Ahora damos doble clic en el botón con la leyenda "Verde" el cual realizará una operación con el numero hexadecimal "0x00ff00" dependiendo de la opción seleccionada en el ComboBox para cambiar todos los colores del bitmap por tonalidades verdes, escribimos el siguiente código:
void __fastcall TForm1::Button2Click(TObject *Sender)
{
switch(ComboBox1->ItemIndex)
{
case 0:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color&0x00ff00;//(TColor)color&255<<8;
}
break;
case 1:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color|0x00ff00;
}
break;
case 2:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color^0x00ff00;
}
break;
case 3:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = ~(TColor)color;
}
break;
}
}
//---------------------------------------------------------------------------
Ahora damos doble clic en el botón que dice "Azul", el cual hará exactamente lo mismo que los anteriores con la diferencia de que éste cambiará todos los colores por tonalidades azules, el código es el siguiente:
void __fastcall TForm1::Button3Click(TObject *Sender)
{
switch(ComboBox1->ItemIndex)
{
case 0:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color&0xff0000;//(TColor)color&255<<16;
}
break;
case 1:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color|0xff0000;
}
break;
case 2:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color^0xff0000;
}
break;
case 3:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = ~(TColor)color;
}
break;
}
}
//---------------------------------------------------------------------------
Ahora en el botón "CopyBrush" escribimos el código para ejemplificar el funcionamiento de las funciones CopyBrush y CopyRect, el código lo tenemos a continuación:
void __fastcall TForm1::Button13Click(TObject *Sender)
{
Form1->Refresh();
Graphics::TBitmap *Bitmap;
TRect rect1, rect2;
rect1 = Rect(10,10,100,100);
rect2 = Rect(450,111,550,201);//(10,111,100,201);
Bitmap=Image1->Picture->Bitmap;
Form1->Canvas->BrushCopy(rect2, Bitmap, rect1, (TColor)color);
Form1->Canvas->CopyRect(rect2, Bitmap->Canvas, rect1);
}
//---------------------------------------------------------------------------
Enseguida manipularemos los pixeles de la imágen bitmap para invertirla, es decir, la dibujaremos de cabeza, el código se muestra a continuación:
void __fastcall TForm1::Button14Click(TObject *Sender)
{
for(int x=0, x2=Image2->Width; x<Image1->Width; x++, x2--)
for(int y=0, y2=Image2->Height; y<Image1->Height; y++, y2--)
Image2->Canvas->Pixels[x2][y2] = Image1->Canvas->Pixels[x][y];
}
//---------------------------------------------------------------------------
Luego lo que haremos será colocar la imágen de lado, es decir tomaremos los pixeles y dibujaremos la imágen acostada con el siguiente código:
void __fastcall TForm1::Button15Click(TObject *Sender)
{
TRect Rect(0,0,Image2->Width,Image2->Height);
Image2->Canvas->FillRect(Rect);
for(int x=0, x2=Image2->Width; x<Image1->Width; x++, x2--)
for(int y=0, y2=Image2->Height; y<Image1->Height; y++, y2--)
Image2->Canvas->Pixels[y2][x2] = Image1->Canvas->Pixels[x][y];
}
//---------------------------------------------------------------------------
Ahora trabajaremos para realizar el zoom a un área de la imágen, para esto utilizaremos 3 eventos. El primero de los eventos que necesitamos es el evento OnMouseDown de el Image1, en el escribimos el siguiente código:
void __fastcall TForm1::Image1MouseDown(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
if(Shift.Contains(ssLeft))
{
left = X;
top = Y;
}
}
//---------------------------------------------------------------------------
Ahora abrimos el evento OnMouseMove de el Image1 y escribimos el código que tenemos a continuación:
void __fastcall TForm1::Image1MouseMove(TObject *Sender, TShiftState Shift,
int X, int Y)
{
if(Shift.Contains(ssLeft))
Image1MouseUp(Sender, mbLeft, Shift, X, Y);
}
//---------------------------------------------------------------------------
El último de los eventos que necesitamos es el OnMouseUp de el Image1, en el cual tecleamos el siguiente código:
void __fastcall TForm1::Image1MouseUp(TObject *Sender, TMouseButton Button,
TShiftState Shift, int X, int Y)
{
if(Button==mbLeft)
{
right = X;
bottom = Y;
Dibujar();
Zoom();
}
}
//---------------------------------------------------------------------------
Con esto ya podemos dibujar un rectángulo sobre el área sobre la cual queremos realizar el zoom y esta aparecerá con el zoom realizado en la parte derecha de la Forma.
Ahora realizaremos otra tarea aprovechando el evento OnMouseDown del Image1, pero esta vez con la opción del botón clic derecho. Lo que haremos será copiar la imágen del Image1 en el Image2 pero quitando los pixeles del color al que le hayamos dado clic en la imágen original, el código es el siguiente (está debajo del código utilizado para el zoom):
void __fastcall TForm1::Image1MouseDown(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
if(Shift.Contains(ssLeft))
{
left = X;
top = Y;
}
if(Shift.Contains(ssRight))
{
Refresh();
TColor color = Image1->Canvas->Pixels[X][Y];
Graphics::TBitmap *Bitmap;
TRect rect1, rect2;
rect1 = Rect(0,0,Image1->Width,Image1->Height);
rect2 = Rect(Image2->Left,Image2->Top,Image2->Left+Image2->Width,Image2->Height+Image2->Top);
Bitmap=Image1->Picture->Bitmap;
Form1->Canvas->BrushCopy(rect2, Bitmap, rect1, (TColor)color);
}
}
//---------------------------------------------------------------------------
Finalmente codificaremos el botón "Cargar Bitmap" para tener la opción de elegir otro bitmap que tengamos en nuestra computadora y poder realizar las mismas acciones que codificamos anteriormente, el código lo tenemos enseguida:
void __fastcall TForm1::Button4Click(TObject *Sender)
{
//Podemos seleccionar un bitmap para cargarlo en la aplicación
Form1->Refresh();
String name;
if(OpenPictureDialog1->Execute())
name = OpenPictureDialog1->FileName;
Image1->Picture->LoadFromFile(name);
}
//---------------------------------------------------------------------------
Y eso es todo chavos, compilamos nuestra aplicación y la corremos para poder probar todas las acciones codificadas, deberíamos tener algo como lo siguiente:
Bueno chavos pues es todo por mi parte, creo que hoy aprendimos muchas cosas nuevas diferentes a las que ya sabíamos anteriormente, yo los espero en la próxima para continuar con más aplicaciones gráficas en C++ Builder. Nos vemos amigos!.
Bueno pues comenzamos agregando los componentes que necesitamos en la Forma, los cuales listamos a continuación:
-1 ComboBox
-2 Image (Del mismo tamaño)
-1 Label
-7 Botones
-1 OpenPictureDialog
La Forma debe quedar de la siguiente manera, en mi caso con la imágen del dragón ya cargada en el Image1:
Ahora configuraremos varios de los componentes. El primero de ellos es el Image1, en su propiedad Picture cargamos la imágen de tipo bitmap que deseemos, en mi caso cargo la imágen de un dragón (yo he descargado varias y les recomiendo hacer lo mismo para tener variedad de imágenes y seleccionar otra cuando queramos). Luego en el ComboBox1 en su propiedad Items agregamos los siguientes:
*AND
*OR
*XOR
*NOT
Ahora vamos al archivo H y en la parte de Private declaramos las siguientes variables:
private: // User declarations
int color, left, top, right, bottom;
Y en la parte Public declaramos los métodos Dibujar() y Zoom() que utilizaremos más delante:
public: // User declarations
__fastcall TForm1(TComponent* Owner);
void TForm1::Dibujar();
void TForm1::Zoom();
Bien pues ahora comenzaremos con la codificación. Primero en el evento de creación del TForm1() agregamos la siguiente línea de código para indicar que al correr la aplicación estará seleccionada la primera opción en el ComboBox:
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
ComboBox1->ItemIndex = 0;
}
//---------------------------------------------------------------------------
Antes de todo abrimos el evento OnCreate de la Forma y escribimos el código siguiente que nos ayudará a reducir el parpadeo:
void __fastcall TForm1::FormCreate(TObject *Sender)
{
Form1->Refresh();
this->DoubleBuffered=true;
}
//---------------------------------------------------------------------------
Después, primero definimos los dos métodos que habíamos declarado anteriormente ya que los utilizaremos más adelante. Primero el método Dibujar():
void TForm1::Dibujar()
{
Refresh();
Form1->Canvas->DrawFocusRect(Rect(left+Image1->Left,top+Image1->Top,right+Image1->Left,bottom+Image1->Top));
}
//---------------------------------------------------------------------------
Después el método Zoom():
void TForm1::Zoom()
{
Graphics::TBitmap *Bitmap;
TRect rect1, rect2;
rect1 = Rect(left,top,right,bottom);
rect2 = Rect(430,50,750,390);
Bitmap=Image1->Picture->Bitmap;
Form1->Canvas->CopyRect(rect2, Bitmap->Canvas, rect1);
}
//---------------------------------------------------------------------------
Ahora escribiremos el botón que dice rojo, el cual dependiendo de la opción que esté seleccionada en el ComboBox realizará una operación de "&", "|", "!" ó "^" con el número hexadecimal "0x0000ff" para cambiar todos los colores del bitmap por tonalidades de color rojo:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
switch(ComboBox1->ItemIndex)
{
case 0:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color&0x0000ff;
}
break;
case 1:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color|0x0000ff;
}
break;
case 2:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color^0x0000ff;
}
break;
case 3:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = ~(TColor)color;
}
break;
}
}
//---------------------------------------------------------------------------
Ahora damos doble clic en el botón con la leyenda "Verde" el cual realizará una operación con el numero hexadecimal "0x00ff00" dependiendo de la opción seleccionada en el ComboBox para cambiar todos los colores del bitmap por tonalidades verdes, escribimos el siguiente código:
void __fastcall TForm1::Button2Click(TObject *Sender)
{
switch(ComboBox1->ItemIndex)
{
case 0:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color&0x00ff00;//(TColor)color&255<<8;
}
break;
case 1:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color|0x00ff00;
}
break;
case 2:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color^0x00ff00;
}
break;
case 3:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = ~(TColor)color;
}
break;
}
}
//---------------------------------------------------------------------------
Ahora damos doble clic en el botón que dice "Azul", el cual hará exactamente lo mismo que los anteriores con la diferencia de que éste cambiará todos los colores por tonalidades azules, el código es el siguiente:
void __fastcall TForm1::Button3Click(TObject *Sender)
{
switch(ComboBox1->ItemIndex)
{
case 0:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color&0xff0000;//(TColor)color&255<<16;
}
break;
case 1:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color|0xff0000;
}
break;
case 2:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = (TColor)color^0xff0000;
}
break;
case 3:
for(int x=0; x<Image1->Width; x++)
for(int y=0; y<Image1->Height; y++)
{
color=Image1->Canvas->Pixels[x][y];
Image2->Canvas->Pixels[x][y] = ~(TColor)color;
}
break;
}
}
//---------------------------------------------------------------------------
Ahora en el botón "CopyBrush" escribimos el código para ejemplificar el funcionamiento de las funciones CopyBrush y CopyRect, el código lo tenemos a continuación:
void __fastcall TForm1::Button13Click(TObject *Sender)
{
Form1->Refresh();
Graphics::TBitmap *Bitmap;
TRect rect1, rect2;
rect1 = Rect(10,10,100,100);
rect2 = Rect(450,111,550,201);//(10,111,100,201);
Bitmap=Image1->Picture->Bitmap;
Form1->Canvas->BrushCopy(rect2, Bitmap, rect1, (TColor)color);
Form1->Canvas->CopyRect(rect2, Bitmap->Canvas, rect1);
}
//---------------------------------------------------------------------------
Enseguida manipularemos los pixeles de la imágen bitmap para invertirla, es decir, la dibujaremos de cabeza, el código se muestra a continuación:
void __fastcall TForm1::Button14Click(TObject *Sender)
{
for(int x=0, x2=Image2->Width; x<Image1->Width; x++, x2--)
for(int y=0, y2=Image2->Height; y<Image1->Height; y++, y2--)
Image2->Canvas->Pixels[x2][y2] = Image1->Canvas->Pixels[x][y];
}
//---------------------------------------------------------------------------
Luego lo que haremos será colocar la imágen de lado, es decir tomaremos los pixeles y dibujaremos la imágen acostada con el siguiente código:
void __fastcall TForm1::Button15Click(TObject *Sender)
{
TRect Rect(0,0,Image2->Width,Image2->Height);
Image2->Canvas->FillRect(Rect);
for(int x=0, x2=Image2->Width; x<Image1->Width; x++, x2--)
for(int y=0, y2=Image2->Height; y<Image1->Height; y++, y2--)
Image2->Canvas->Pixels[y2][x2] = Image1->Canvas->Pixels[x][y];
}
//---------------------------------------------------------------------------
Ahora trabajaremos para realizar el zoom a un área de la imágen, para esto utilizaremos 3 eventos. El primero de los eventos que necesitamos es el evento OnMouseDown de el Image1, en el escribimos el siguiente código:
void __fastcall TForm1::Image1MouseDown(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
if(Shift.Contains(ssLeft))
{
left = X;
top = Y;
}
}
//---------------------------------------------------------------------------
Ahora abrimos el evento OnMouseMove de el Image1 y escribimos el código que tenemos a continuación:
void __fastcall TForm1::Image1MouseMove(TObject *Sender, TShiftState Shift,
int X, int Y)
{
if(Shift.Contains(ssLeft))
Image1MouseUp(Sender, mbLeft, Shift, X, Y);
}
//---------------------------------------------------------------------------
El último de los eventos que necesitamos es el OnMouseUp de el Image1, en el cual tecleamos el siguiente código:
void __fastcall TForm1::Image1MouseUp(TObject *Sender, TMouseButton Button,
TShiftState Shift, int X, int Y)
{
if(Button==mbLeft)
{
right = X;
bottom = Y;
Dibujar();
Zoom();
}
}
//---------------------------------------------------------------------------
Con esto ya podemos dibujar un rectángulo sobre el área sobre la cual queremos realizar el zoom y esta aparecerá con el zoom realizado en la parte derecha de la Forma.
Ahora realizaremos otra tarea aprovechando el evento OnMouseDown del Image1, pero esta vez con la opción del botón clic derecho. Lo que haremos será copiar la imágen del Image1 en el Image2 pero quitando los pixeles del color al que le hayamos dado clic en la imágen original, el código es el siguiente (está debajo del código utilizado para el zoom):
void __fastcall TForm1::Image1MouseDown(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
if(Shift.Contains(ssLeft))
{
left = X;
top = Y;
}
if(Shift.Contains(ssRight))
{
Refresh();
TColor color = Image1->Canvas->Pixels[X][Y];
Graphics::TBitmap *Bitmap;
TRect rect1, rect2;
rect1 = Rect(0,0,Image1->Width,Image1->Height);
rect2 = Rect(Image2->Left,Image2->Top,Image2->Left+Image2->Width,Image2->Height+Image2->Top);
Bitmap=Image1->Picture->Bitmap;
Form1->Canvas->BrushCopy(rect2, Bitmap, rect1, (TColor)color);
}
}
//---------------------------------------------------------------------------
Finalmente codificaremos el botón "Cargar Bitmap" para tener la opción de elegir otro bitmap que tengamos en nuestra computadora y poder realizar las mismas acciones que codificamos anteriormente, el código lo tenemos enseguida:
void __fastcall TForm1::Button4Click(TObject *Sender)
{
//Podemos seleccionar un bitmap para cargarlo en la aplicación
Form1->Refresh();
String name;
if(OpenPictureDialog1->Execute())
name = OpenPictureDialog1->FileName;
Image1->Picture->LoadFromFile(name);
}
//---------------------------------------------------------------------------
Y eso es todo chavos, compilamos nuestra aplicación y la corremos para poder probar todas las acciones codificadas, deberíamos tener algo como lo siguiente:
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
.png){kind=link}
Bueno chavos pues es todo por mi parte, creo que hoy aprendimos muchas cosas nuevas diferentes a las que ya sabíamos anteriormente, yo los espero en la próxima para continuar con más aplicaciones gráficas en C++ Builder. Nos vemos amigos!.
Suscribirse a:
Entradas (Atom)