Vistas de página en total

sábado, 15 de octubre de 2011

simular paint

Nuestra aplicación dibuja lineas, círculos y espirales, con ayuda de una clase gráficos que les muestro a continuación.

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


#pragma hdrstop
#include <math.h>
#include "Graficos1.h"

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

#pragma package(smart_init)
   void Graficos::linea(int x1,int y1,int x2,int y2,TColor color)
   {
    int dx,dy,steps,k,n,m;
    float x_inc,y_inc,x,y;
    dx=x2-x1;
    dy=y2-y1;
    if(abs(dx)>abs(dy))
    steps=abs(dx);
    else
    steps=abs(dy);
    x_inc=(float)dx/steps;
    y_inc=(float)dy/steps;
    x=x1;
    y=y1;
    n=static_cast<int>(x);
    m=static_cast<int>(y);
    canvas->Pixels[n][m]=clBlue;
    for(k=1;k<steps+1;k++)
    {
     x=x+x_inc;
     y=y+y_inc;
     n=static_cast<int>(x);
     m=static_cast<int>(y);
     canvas->Pixels[n][m]=clBlue;
    }

   }

   //--------------------------------
   void Graficos::linea(int x1,int y1,int x2,int y2)
   {
    int dx,dy,steps,k,n,m;
    float x_inc,y_inc,x,y;
    dx=x2-x1;
    dy=y2-y1;
    if(abs(dx)>abs(dy))
    steps=abs(dx);
    else
    steps=abs(dy);
    x_inc=(float)dx/steps;
    y_inc=(float)dy/steps;
    x=x1;
    y=y1;
    n=static_cast<int>(x);
    m=static_cast<int>(y);
    canvas->Pixels[n][m]=(TColor)random(255);//clBlue;
    for(k=1;k<steps+1;k++)
    {
     x=x+x_inc;
     y=y+y_inc;
     n=static_cast<int>(x);
     m=static_cast<int>(y);
     canvas->Pixels[n][m]=(TColor)random(255);//clBlue;
    }

   }

  void Graficos::circulo_1(int x1,int y1)
   {
        //int r=Edit3->Text.ToIntDef(50);
    int xc=x1;
    int yc=y1;
    int x,y,r;
    r=xc/2;
    x=r;
    for(int i=0;i<=r;i++)
    {
      y = yc + sqrt((r*r)-((x-xc)*(x-xc)));
      x++;
      canvas->Pixels[x][static_cast<int>(y)]=clBlue;
    }
    x=r;
    //xc=100;
    //yc=100;
    for(int i=0;i<=r;i++)
    {
      y =  yc - sqrt((r*r)-((x-xc)*(x-xc)));
      x++;
      canvas->Pixels[x][static_cast<int>(y)]=clBlue;
    }
     x=xc;
    //xc=100;
    //yc=100;
    for(int i=0;i<=r;i++)
    {
      y =  yc + sqrt((r*r)-((x-xc)*(x-xc)));
      x++;
      canvas->Pixels[x][static_cast<int>(y)]=clBlue;
    }
    x=xc;
    //xc=100;
    //yc=100;
    for(int i=0;i<=r;i++)
    {
      y =  yc - sqrt((r*r)-((x-xc)*(x-xc)));
      x++;
      canvas->Pixels[x][static_cast<int>(y)]=clBlue;
    }
   }

void Graficos::circulo_2(int x1,int y1,int r)
{
  float dt,ct,st,x,y,xtemp;
  dt=1.0/r;
 x=0;
 y=r;
 ct=cos(dt);
 st=sin(dt);
 while(x<=y)
 {
   canvas->Pixels[static_cast<int>(x1+x)][static_cast<int>(y1+y)]=clBlue;
    canvas->Pixels[static_cast<int>(x1-x)][static_cast<int>(y1+y)]=clRed;
     canvas->Pixels[static_cast<int>(x1+x)][static_cast<int>(y1-y)]=clOlive;
      canvas->Pixels[static_cast<int>(x1-x)][static_cast<int>(y1-y)]=clSkyBlue;
   xtemp=x;
   x=x*ct-y*st;
   y=y*ct+xtemp*st;
 }
}

void Graficos::circulo_3(int x1,int y1,int r)
{
  float pi=M_PI*2.0;
   float dth,ct,st,x,y,xtemp;
  if(r!=0)
  {
   dth=pi/(16*r);
   ct=cos(dth);
   st=sin(dth);
   x=0;
   y=r;
   for(int i=0;i<=(16*r);i++)
   {
    xtemp=x;
    x=x*ct+y*st;
    y=y*ct-xtemp*st;
    canvas->Pixels[static_cast<int>(x1+x)][static_cast<int>(y1+y)]=clSkyBlue;
    Sleep(30);
   }
  }
}

 void Graficos::circulo_4(int x1,int y1,int r)
 {
   int x,y;
   for(int grados=0;grados<360;grados++)
   {
    x=x1+r*cos(grados/180.0+M_PI);
    y=y1+r*sin(grados/180.0+M_PI);
    canvas->Pixels[x][y]=clBlue;
    Sleep(10);
   }
   for(int grados=0;grados<360;grados++)
   {
    x=x1+r*cos(grados/90.0+M_PI);
    y=y1+r*sin(grados/90.0+M_PI);
    canvas->Pixels[x][y]=clBlue;
    Sleep(10);
   }
    for(int grados=0;grados<360;grados++)
   {
    x=x1+r*cos(grados/M_PI);
    y=y1+r*sin(grados/M_PI);
    canvas->Pixels[x][y]=clBlue;
    Sleep(10);
   }
 }

recibimos las coordenadas de el área donde quiere el usuario dibujar y con un botton hacemos el llamado al método de la clase gráficos.
los espirales los hacemos dibujando lineas del método linea como sigue:
int xc=Form1->PaintBox1->ClientWidth/2, yc=Form1->PaintBox1->ClientHeight/2,radio=5;
  double pi=M_PI*2.0;
  int count=0;
  double dth,cth,sth,x,y,x_temp,xt,yt;
  dth=pi/(16*radio);
  cth=cos(dth);
  sth=sin(dth);
  x=0.0;
  y=radio;
  xt=xc+x;
  yt=yc+y;
  do
  {
    x_temp=x;
    x=x*cth-y*sth;
    y=y*cth+x_temp*sth;
    if(x>0)
      x +=0.5;
    else
      x-=0.5;
    if(y>0)
      y+=0.5;
    else
      y-=0.5;
    //Form1->PaintBox1->Canvas->Pixels[floor(xt+0.5)][floor(yt+0.5)]=clRed;
    /*x1=floor(xt+0.5);
    y1=floor(yt+0.5);
    x2=floor(xc+0.5);
    y2=floor(yc+0.5);
    g->linea(x1,y1,x2,y2);*/
    xt=xc+x;
    yt=yc+y;
    count++;
    Sleep(5);
    }
    while(count<=350);

Así quedo nuestra aplicación.
dibujando linea:
dibujando el circulo dado el centro de este
dibujando circulo con coordenadas del centro y radio
dibujando el circulo poco a poco:

dibujando el circulo calculando los ángulos:


dibujando espiral:
espiral 1:

espiral 2:


Agregando efectos a espiral:



Aquí puedes descargar




 

Fractal de ecena

esta aplicación es un paisaje en movimiento, dibujo un sol y dos lineas que simulan la playa y el relieve, aplico color para simular el paisaje.
este es el código del fractal

#define MAXLEVEL 6
#define MAXSIZE 1000
#define WATER 1
#define SUN 2
#define SKY 3
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 int x1;
double frctl[MAXSIZE];
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
 void TForm1::fractal(int y1,int y2,int maxlevel,double h,double scale)
{
        int first, last;
        double ratio,std;

        first=0;
        last=(int)pow(2.0,(double)maxlevel);
        frctl[first]=y1;
        frctl[last]=y2;
        ratio=1.0/pow(2.0,h);
        std=scale*ratio;
        subdivide(first,last,std,ratio);
}
void TForm1::subdivide(int p1,int p2,double std,double ratio)
{
        int midpnt;
        double stdmid;
        midpnt = (p1 + p2) / 2;
        if(midpnt != p1 && midpnt != p2)
        {
                frctl[midpnt] = (frctl[p1] + frctl[p2]) / 2 + (double)((random(16)-8)) /8.0*std;
                stdmid = std * ratio;
                subdivide(p1,midpnt,stdmid,ratio);
                subdivide(midpnt,p2,stdmid,ratio);
        }
}
void TForm1::draw_fractal()
{
        int i,x,xinc,l;

        l=(int)pow(2.0,(double)MAXLEVEL);
        xinc = cw / l * 3 / 2;
        Form1->PaintBox1->Canvas->MoveTo(.5,100);
        for(i=0,x=0;i<l;i++,x+=xinc)
                Form1->PaintBox1->Canvas->LineTo(x,(int)frctl[i]);

}
void __fastcall TForm1::FormCreate(TObject *Sender)
{
        cw=Form1->PaintBox1->ClientWidth;
        ch=Form1->PaintBox1->ClientHeight;
        x1=50;    
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
     x1++;
        randomize();

       Form1->PaintBox1->Canvas->Brush->Color=clOlive;
        Form1->PaintBox1->Canvas->Rectangle(0,0,cw,ch);
        Form1->PaintBox1->Canvas->Brush->Color=clBlue;//Color del cielo
        Form1->PaintBox1->Canvas->Pen->Color=clMaroon;//contorno de la montaña
        fractal(100,100,MAXLEVEL,.75,50.0);
        draw_fractal();

        Form1->PaintBox1->Canvas->FloodFill(1,2,clMaroon,fsBorder); //fsSurface ó fsBorder
        Form1->PaintBox1->Canvas->Pen->Color=clGreen;


        fractal(170,170,MAXLEVEL,0.9,30.0);
        draw_fractal();           // (TColor)WATER,fsSurface
        Form1->PaintBox1->Canvas->Brush->Color=clSkyBlue;
        Form1->PaintBox1->Canvas->FloodFill(1,ch-2,clGreen,fsBorder);

        Form1->PaintBox1->Canvas->Brush->Color=clYellow;//relleno del sol

        Form1->PaintBox1->Canvas->Ellipse(5+x1,5,40+x1,40);
        Form1->PaintBox1->Canvas->FloodFill(cw-100    ,10,(TColor)SUN,fsSurface);


}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
   Timer1->Enabled=true;
}
//------------------------


Este es el resultado:



aquí puedes descargar

Fractal del Dragon

En esta aplicación dibujamos el fractal del dragón la cual es una imagen compuesta por lineas del mismo tamaño.
Este es el método que genera al dragón:


 void TForm1::GenerarDragon(TColor color)
 {
   int i, j,dx,dy;
   j=Paso/2;
//setcolor(color);
   Canvas->Pen->Color=color;
   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))/2;
   EjeY[i+j]=EjeY[i]+(dy-(dx*Signo))/2;

   Canvas->MoveTo(EjeX[i],EjeY[i]);
   Canvas->LineTo(EjeX[i+j],EjeY[i+j]);
  Canvas->MoveTo(EjeX[i+j],EjeY[i+j]);
   Canvas-> LineTo(EjeX[i+Paso],EjeY[i+Paso]);
   
   Sleep(1);

  }
 }

Este es el resultado;

Aqui puedes descargar

fractal Mandelbrot

En esta aplicacion dibujamos el gractal de Mandelbrot en c++ builder.
este es el codigo para dibujarlo:


this->Repaint();
  maxx=this->ClientWidth;
  maxy=this->ClientHeight;
  Limite=100;
  OrigX=-2.0;
  OrigY=-1.25;
  DimX=0.5;
  DimY=1.25;
  PasoX=(DimX-OrigX)/maxx;
  PasoY=(DimY-OrigY)/maxy;

  for(int i=0;i<=maxx;i++)
  for(int 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)
        this->Canvas->Pixels[i][j]=clBlue;
    }

y este es el resultado:


aquí puedes descargarlo

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