Vistas de página en total

sábado, 15 de octubre de 2011

fractal Newton Raphson

Adentrándonos en el mundo de los fractales iniciamos con codificar en c++ builder el fractal de Newton Raphson.

para esto quitamos el form de nuestra aplicación y agregamos el código para hacer el form a pie,
a ver que les parece:


//Fractal de Newton-Raphson

//#include <windows.h>

//--- 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] = 192+i;//0;
ColorRGB[i][2] = 192+i;//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] = (192+i)-128;//0;
ColorRGB[i][1] =0;
ColorRGB[i][2] = 0;//(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 =-4.0, ymin=-4.0, xmax=6.0, ymax=6.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.bottom - rect.top;//rect.right - rect.left ;
maxrow = rect.right - rect.left ;//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, row, col, 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 ==========================
asi queda la aplicación:

Aqui puedes descargarlo

Trabajar con Imagene

En esta aplicación jugamos con una imagen; tomamos cada pixel de la imagen previamente cargada y la colocamos en otro image cambiando el color de los pixeles, o cambiando su posición para mostrarla de cabeza o como reflejo.
para esto tomamos el color de el pixel en la posición x,y, y lo colocamos en la segunda image con el mismo color o cambiando de color y jugando con las posiciones de estos.
Por ejemplo así quedaría el método o botton para reflejar la image

    TColor color;
   int y= Image1->ClientWidth;
   for(int j=0;j<Image1->ClientWidth;j++)
{
    for(int i=0;i<Image1->ClientHeight;i++)
    {
    color=Image1->Canvas->Pixels[j][i];

     Image2->Canvas->Pixels[y][i]=color;


    }
        y--;
}

Asi quedo nuestra Aplicacion:

pintamos los pixeles de color rojo
de color verde 
de color azul

imagen de cabeza
reflejo de la imagen
esta aplicacion tambien te permite dar zoom a la imagen con solo dar clic sobre ella

y esta es nuestra aplicación...
Aqui puedes descargarla

jueves, 15 de septiembre de 2011

Mas y mas pixeles

Por medio de esta aplicacion agregamos pixeles a un image de manera aleatoria cada determinado tiempo
para lo cual utilizamos un timer, cada vez que manipulamos los botones se borran los pixeles y empieza el ciclo de nuevo...
Aqui el ejemplo!!!
Eata es su función al dar clic el boton rojo

Al dar clic al boton verde


Esta es la función del boton azul


Si deseas descargarlo aqui puedes

domingo, 11 de septiembre de 2011

combinación de colores

En esta aplicación manipularemos colores...
El panel que colocamos va a cambiar de color al movimiento de los trackbar
como se muestra en la imagen... veremos
moviendo el trackbar rojo



movimiento trackbar verde

movimiento del azul

combinación de rojo y azul
combinación de rojo y verde

                                          
combinación de verde y azul

                                 
combinación de los tres colores


en esta aplicacion también manipulamos pixeles de colores...
cada vez que se oprime un botón se dibujan pixeles en el image...

descargar archivo aquí!!!!!


sábado, 10 de septiembre de 2011

mas de movimientos de pixeles

hey  aqui tienen otra aplicacion de movimientos de pixeles...

aqui el pixel se mueve por el contorno de el form hasta que termina formando un rectangulo
y vuelve a empezar...


Para ver el codigo puedes descaargar el archivo aqui 

domingo, 4 de septiembre de 2011

camino de un pixel

Esta aplicacion consiste en mover un pixel en la form, hacia a delante y de regreso..
es muy sencillo:
primero agregamos un timer a nuestra form y las variables a utilizar en el archivo h. en la parte de private
las variables son las siguientes:

int x,y,mx,my;//x y y son las cordenadas del pixel
 bool c,d;//banderas

agregamos el siguiente codigo a los metodos siguientes:


void __fastcall TForm1::Timer1Timer(TObject *Sender)
{

    // Calcular su nueva posició
        if(x==mx)
    {
     c=true;
    }
    if(x==10)
    {
     c=false;
    }
      if (x <mx&&c==false )
   {
    Canvas->Pixels[x][y] = clWhite;
    x += (x < mx)*1 +
    (x > mx)*-1;

    }
    else
    {

     if (x <=mx&&c==true )
     {
          Canvas->Pixels[x][y] = clBlue;
        x -= 1;

    }
    }
    Canvas->Pixels[x][y] = clRed;//Black;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormPaint(TObject *Sender)
{
    x=10;
    y=10;
    mx=ClientWidth-10;
    my=ClientHeight;
    c=false;
}


y este es el resultado ajua!!



cuando va hacia adelante pinta el camino blanco y cuando regresa lo hace en azul...


Aqui esta el archivo para descargar.....

Movimiento de pixeles


En este proyecto veremos como mostrar pixeles en una aplicación en c++ builder, y como desplazarlos hacia el centro de cada uno de los cuadrantes y se borran cuando llegan al centro.


Ejemplo:


Para esto hacemos uso de POINT que cuenta con un campo para la posición x y y de cada pixel.


Agregamos las siguientes variables en el archivo h. de la Tform en la parte de private:

   POINT Puntos[1000]; // Matriz para mantener la posición de 1000 puntos
    int Contador; // Contador general para la matriz anterior
    int MediaX, MediaY,MediaXC,MediaYC,MediaXS, MediaYS,MediaXT, MediaYT; // Puntos medios del área de dibujo


métodos

agregamos un timer a la forma y el siguiente código en sus respectivos 

void __fastcall TForm1::FormPaint(TObject *Sender)
{
    for(int N = 0; N < 1000; N++)
{ // Calcular los 1000 puntos
Puntos[N].x = random(ClientWidth); // de forma aleatoria
Puntos[N].y = random(ClientHeight);
Canvas->Pixels[Puntos[N].x][Puntos[N].y] = clBlack;
}
Contador = 0; // Inicializar el contador
//primer cuadrante
MediaX = (ClientWidth / 2)/2; // Y calcular el punto medio
MediaY = (ClientHeight / 2)/2;
//tercero cuadrante
MediaXC=ClientWidth - (ClientWidth / 2)/2;
MediaYC=ClientHeight - (ClientHeight / 2)/2;
//cuarto cuadrante
 MediaXS=((ClientWidth - ((ClientHeight / 2)-((ClientWidth / 2)/2)/2))/2)/2;
 MediaYS=ClientHeight - ((ClientHeight / 2)-(ClientHeight / 2)/2);
 //segundo cuadrante
  MediaXT=ClientWidth -((ClientWidth / 2)- (ClientWidth / 2)/2);
 MediaYT=((ClientHeight -( (ClientHeight / 2)-(ClientHeight / 2)/2))/2)/2;
}
//---------------------------------------------------------------------------


void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
      for (int N = 0; N < 100; N++)
    {// Desplazar 100 puntos en cada ciclo, probar en vez de 100 - 1000
    // Desactivar el punto de su posición actual
    Canvas->Pixels[Puntos[Contador].x][Puntos[Contador].y] = clBlack;
    // Calcular su nueva posición
      if (Puntos[Contador].x < (ClientWidth / 2) && Puntos[Contador].y <(ClientHeight / 2))
   {
    Puntos[Contador].x += (Puntos[Contador].x < MediaX)*1 +
    (Puntos[Contador].x > MediaX)*-1;
    Puntos[Contador].y += (Puntos[Contador].y < MediaY)*1 +
    (Puntos[Contador].y > MediaY)*-1;
    }


   // Si el punto está en el centro del área debe desaparecer
   if (Puntos[Contador].x == MediaX && Puntos[Contador].y == MediaY)
   {
   // Reapareciendo en un punto aleatorio
   Puntos[Contador].x = random(ClientWidth);
   Puntos[Contador].y = random(ClientHeight);
   }
    if (Puntos[Contador].x < (ClientWidth )&&Puntos[Contador].x > (ClientWidth/2 ) && Puntos[Contador].y <(ClientHeight )&&Puntos[Contador].y >(ClientHeight/2 ))
   {
   Puntos[Contador].x += (Puntos[Contador].x < MediaXC)*1 +
    (Puntos[Contador].x > MediaXC)*-1;
   Puntos[Contador].y += (Puntos[Contador].y < MediaYC)*1 +
    (Puntos[Contador].y > MediaYC)*-1;
    }
    if (Puntos[Contador].x < (ClientWidth/2 ) && Puntos[Contador].y <(ClientHeight )&&Puntos[Contador].y >(ClientHeight/2 ))
   {
   Puntos[Contador].x += (Puntos[Contador].x < MediaXS)*1 +
    (Puntos[Contador].x > MediaXS)*-1;
   Puntos[Contador].y += (Puntos[Contador].y < MediaYS)*1 +
    (Puntos[Contador].y > MediaYS)*-1;
    }
   
    if (Puntos[Contador].x < (ClientWidth/2 ) && Puntos[Contador].y <(ClientHeight )&&Puntos[Contador].y >(ClientHeight/2 ))
   {
   Puntos[Contador].x += (Puntos[Contador].x < MediaXS)*1 +
    (Puntos[Contador].x > MediaXS)*-1;
   Puntos[Contador].y += (Puntos[Contador].y < MediaYS)*1 +
    (Puntos[Contador].y > MediaYS)*-1;
    }
      if (Puntos[Contador].x > (ClientWidth / 2)&&Puntos[Contador].x < (ClientWidth) && Puntos[Contador].y <(ClientHeight / 2))
   {
    Puntos[Contador].x += (Puntos[Contador].x < MediaXT)*1 +
    (Puntos[Contador].x > MediaXT)*-1;
    Puntos[Contador].y += (Puntos[Contador].y < MediaYT)*1 +
    (Puntos[Contador].y > MediaYT)*-1;
    }
   // Mostrarlo en la nueva posición
   Canvas->Pixels[Puntos[Contador].x][Puntos[Contador].y] = clRed;//Black;
   Contador++; // Pasar al punto siguiente
   // O al primero si ya se han recorrido todos
   if (Contador == 1000)
     Contador = 0;
    }


}



Así 

funciona nuestro programa:




Aqui puedes descargar el archivo