Vistas de página en total

viernes, 18 de noviembre de 2011

juego de numeros

Esta aplicación es un juego el cual consiste en acomodar los números del 1 al 15.
les voy a mostrar primero como quedo y después el código para que lo vallan entendiendo sale:

al dar clic a play te aparece la plantilla para iniciar el juego

para mover un numero tienes que dar clic sobre el numero, este se moverá solamente si el cuadro continuo en cualquier dirección esta vació.

aquí tienen el código:

int h;
int cont=0;
int r=0;
int pri1[17];
int fig1[4][4] ;
//arreglo ya definido para checar la posición de las imagenes cuando se gane
int gan[4][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11},{12,13,14,15}};

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
 //cargo las imagenes en el arreglo imageObject
   ImageObject[0] = new Graphics::TBitmap;
    ImageObject[0]->LoadFromFile("l1.bmp");
   // ImageObject[0]->Transparent = True;
    ImageObject[1] = new Graphics::TBitmap;
    ImageObject[1]->LoadFromFile("l2.bmp");
   // ImageObject[1]->Transparent = True;
    ImageObject[2] = new Graphics::TBitmap;
    ImageObject[2]->LoadFromFile("l3.bmp");
   // ImageObject[2]->Transparent = True;
     ImageObject[3] = new Graphics::TBitmap;
   ImageObject[3]->LoadFromFile("l4.bmp");
    //ImageObject[3]->Transparent = True;
    ImageObject[4] = new Graphics::TBitmap;
  ImageObject[4]->LoadFromFile("l5.bmp");
   // ImageObject[4]->Transparent = True;
     ImageObject[5] = new Graphics::TBitmap;
  ImageObject[5]->LoadFromFile("l6.bmp");
    //ImageObject[5]->Transparent = True;
     ImageObject[6] = new Graphics::TBitmap;
    ImageObject[6]->LoadFromFile("7.bmp");
   // ImageObject[6]->Transparent = True;
    ImageObject[7] = new Graphics::TBitmap;
    ImageObject[7]->LoadFromFile("l8.bmp");
    //ImageObject[7]->Transparent = True;
     ImageObject[8] = new Graphics::TBitmap;
    ImageObject[8]->LoadFromFile("l9.bmp");
    //ImageObject[8]->Transparent = True;
     ImageObject[9] = new Graphics::TBitmap;
    ImageObject[9]->LoadFromFile("l10.bmp");
  //  ImageObject[9]->Transparent = True;
    ImageObject[10] = new Graphics::TBitmap;
    ImageObject[10]->LoadFromFile("l11.bmp");
   // ImageObject[10]->Transparent = True;
     ImageObject[11] = new Graphics::TBitmap;
    ImageObject[11]->LoadFromFile("l12.bmp");
   // ImageObject[11]->Transparent = True;
     ImageObject[12] = new Graphics::TBitmap;
    ImageObject[12]->LoadFromFile("l13.bmp");
   // ImageObject[12]->Transparent = True;
    ImageObject[13] = new Graphics::TBitmap;
    ImageObject[13]->LoadFromFile("l14.bmp");
   // ImageObject[13]->Transparent = True;
    ImageObject[14] = new Graphics::TBitmap;
    ImageObject[14]->LoadFromFile("l15.bmp");
   // ImageObject[14]->Transparent = True;
     ImageObject[15] = new Graphics::TBitmap;
    ImageObject[15]->LoadFromFile("lv.bmp");
   // ImageObject[15]->Transparent = True;


}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{

    Form1->InitiateAction();
   Form1->PaintBox1->Repaint();
   r=0;
   cont=0;
 //ciclo para obtener los números del 1 al 16 de manera aleatoria para poder saber en que posición se van a
//dibujar las imágenes (números)
   int n=0;
    for(int i=0;i<=100;i++)
    {
       int r=0+rand()%16;
       for(int j=0;j<=n;j++)
       {
        if(pri1[j]==r)
        {
         j=n+1;
         n=n-1;
        }
        if(j==n)
        {

         pri1[n]=r;

        }

       }
        n++;
        if(n==17)
        {
         break;
        }

    }
    //guarda el numero de la imagen en la matris fig1, este numero es la posicion que tiene la imagen en el arreglo imaenObject
     int l=0;
     for(int y=0;y<4;y++)
     {
      for(int j=0;j<4;j++)
      {
       fig1[j][y]=pri1[l];
       l++;
      }
     }
//matriz que contienen el área donde se dibujaran las imágenes
    int x[4]={0,PaintBox1->ClientWidth/4,PaintBox1->ClientWidth/2,(PaintBox1->ClientWidth/4)*3};
     int y[4]={0,PaintBox1->ClientHeight/4,PaintBox1->ClientHeight/2,(PaintBox1->ClientHeight/4)*3};
    //if(r==1)
   // {
    Label1->Caption=1;
    //array
    h=1;
//ciclo para dibujar las imágenes en pantalla
    int f=0;
    for(int i=0;i<4;i++)
    {
     for(int j=0;j<4;j++)
     {
      PaintBox1->Canvas->Draw(x[i],y[j], ImageObject[pri1[f]]);
      f++;
      }
      }


}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
   PaintBox1->Canvas->Font->Color = clBlue;
   PaintBox1->Canvas->Font->Size = 30;
   int xl,yl;
   int k=0;
//area de dibujo
    int x[5]={0,PaintBox1->ClientWidth/4,PaintBox1->ClientWidthClientWidth/4)*3,PaintBox1->ClientWidth};
    int y[5]={0,PaintBox1->ClientHeight/4,PaintBox1->ClientHeight/2,(PaintBox1->ClientHeight/4)*3,PaintBox1->ClientHeight};
//checas X,Y que son las coordenados que se obtienen al dar clic sobre la imagen con el área de dibujo
    for(int i=0;i<4;i++)
    {
      if(X>x[i]&&X<x[i+1])
      {
       xl=i;
      }

    }
    for(int i=0;i<4;i++)
    {
      if(Y>y[i]&&Y<y[i+1])
      {
       yl=i;
      }

    }
  Label1->Caption=cont;
if(h==1)
{
//aquí se checa si la imagen sobre la cual se dio clic es continua de la imagen sin numero que es la imagen en posición numero 15, si es así cambia una imagen por otra
  k=fig1[yl][xl];
  if(fig1[yl+1][xl]==15)//
  {
    cont++;
  // Label1->Caption=cont;
   PaintBox1->Canvas->Draw(x[xl],y[yl],ImageObject[15]);
   PaintBox1->Canvas->Draw(x[xl],y[yl+1],ImageObject[k]);
   fig1[yl][xl]=15;
   fig1[yl+1][xl]=k;
   }
   else
   {
   if(fig1[yl-1][xl]==15)//||fig1[xl+1][yl]==15||fig1[xl-1][yl]==15)
  {
    cont++;
 // Label1->Caption=cont;
   PaintBox1->Canvas->Draw(x[xl],y[yl],ImageObject[15]);
   PaintBox1->Canvas->Draw(x[xl],y[yl-1],ImageObject[k]);
   fig1[yl][xl]=15;
   fig1[yl-1][xl]=k;
   }
   else
   {
   if(fig1[yl][xl+1]==15)//||fig1[xl-1][yl]==15)
  {
    cont++;
 // Label1->Caption=cont;
   PaintBox1->Canvas->Draw(x[xl],y[yl],ImageObject[15]);
   PaintBox1->Canvas->Draw(x[xl+1],y[yl],ImageObject[k]);
   fig1[yl][xl]=15;
   fig1[yl][xl+1]=k;
   }
   else
   {
   if(fig1[yl][xl-1]==15)
  {
    cont++;

   PaintBox1->Canvas->Draw(x[xl],y[yl],ImageObject[15]);
   PaintBox1->Canvas->Draw(x[xl-1],y[yl],ImageObject[k]);
   fig1[yl][xl]=15;
   fig1[yl][xl-1]=k;
   }
   }
   }
   }
  //fig1[yl][xl]=15;
//método para verificar si ya se gano
  if(ganar(h))
  {

    String text = "Ya ganste";
   PaintBox1->Canvas->TextOut(100,310, text);
  }
  }

}
//---------------------------------------------------------------------------
  bool TForm1::ganar(int h)
  {
   // si la matriz fig que es la que contiene la posición actual de las imágenes es igual a la de gan entonces abras ganado
    bool t=true;
      if(h==1)
      {
       for(int i=0;i<4;i++)
        {
       for(int j=0;j<4;j++)
        {
         if(fig1[i][j]!= gan[i][j])
        {
          return t=false;
         }
         }
        }
       }
      return t=true;
  }
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
  r++;
  Label4->Caption=r;
}



uf al fin gane, créanme no soy buena jugando, y eso que yo lo programe verdad pero bueno.
aquí tienen el código para descargarlo

Fractal Mandelbrot en C#

Anteriormente hice una publicación de el fractal conocido como el fractal de mandelbrot, en una aplicación en c++ builder, en esta aplicación utilizo el mismo algoritmo pero implementado en c#.
 aquí les dejo el código de dicha aplicación:



int maxx, maxy, Limite, Pasos, Terminar;
        double PasoX, PasoY, PosX, PosY, OrigX, OrigY, DimX, DimY, IterX, IterY, TempX;
        public Form1()
        {
            InitializeComponent();
        }


        private void button1_Click(object sender, EventArgs e)
        {
            this.Refresh();
            Bitmap bmp = new Bitmap(this.ClientSize.Width, ClientSize.Height);
            maxx = this.ClientSize.Width;
            maxy = this.ClientSize.Height;
            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==0)
                    {
                        TempX = (IterX * IterX) - (IterY * IterY) + PosX;
                        IterY = 2 * (IterX * IterY) + PosY;
                        IterX = TempX;
                        Pasos++;
                       double r, s;
                        r = (double)Math.Abs(IterX) * Math.Abs(IterX);
                        s =(double) Math.Abs(IterY) * Math.Abs(IterY);
                        if (Math.Sqrt(r+s) >= 2.0)
                            Terminar++;
                        if (Pasos >= Limite) Terminar++;
               
                           i=maxx;
                           j=maxy;
                           Terminar++;
                     
                    }
                    if (Pasos < Limite)
                        bmp.SetPixel(i, j, Color.Blue);
                   
                }
            Graphics g = this.CreateGraphics();
            g.DrawImage(bmp, 0, 0, bmp.Width, bmp.Height);
        }




esta es la ejecución de este código:






aqui puedes descargar la aplicación.

Fractal del Dragon en c#

Recuerdan una publicación anterior donde les presentaba el fractal del dragón usando el algoritmo del dragón el cual esta compuesto por segmentos de lineas que se cruzan siempre en angulo de 90º 


este es el código en c#:



      int Paso = 4096;
        int Signo = -1;
        float[] EjeX = new float[4098];
        float[] EjeY = new float[4098];
        public Form1()
        {
            InitializeComponent();
        }


        private void button1_Click(object sender, EventArgs e)
        {
            timer1.Enabled = true;
        }


        private void timer1_Tick(object sender, EventArgs e)
        {
            int i;
            Paso = 4096;
            Signo = -1;
            EjeX[1] = pictureBox1.ClientSize.Width / 4; 
            EjeX[4097] = 2 * pictureBox1.ClientSize.Height / 4;
            EjeY[1] = EjeY[4097] = 2 * pictureBox1.ClientSize.Width / 4;
         
            Random ra = new Random();
           Thread.Sleep(1);
        
            for (i = 1; i <= 13; i++)
            {
              
                Refresh();
            
                GenerarDragon();//TColor(RGB(random(256), 0, 0)));
                Paso /= 2;
                 Thread.Sleep(1);
                //delay(1000);
            }


        }
   
        public void GenerarDragon()
        {
            int i, j;
            float dx, dy;
            float x1,y1,x2,y2,x3,y3;
            j = Paso / 2;
           
 Random val = new Random();

            Pen pluma = new Pen(Color.FromArgb(val.Next(256), val.Next(256), val.Next(256)));
//clase estatica de c# para dibujar graficos
            Graphics g = pictureBox1.CreateGraphics();
            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;
               
                x1 = EjeX[i];
                y1 = EjeY[i];
                x2 = EjeX[i + j];
                y2 = EjeY[i + j];
                x3 = EjeX[i + Paso];
                y3 = EjeY[i + Paso];
                g.DrawLine(pluma, x1, y1,x2,y2);
                g.DrawLine(pluma, x2, y2,x3,y3);
              
                
                Thread.Sleep(1);


            }
        }


        private void button2_Click(object sender, EventArgs e)
        {
            timer1.Enabled = false;
            this.Close();
        }


este es el resultado de esta 

aplicación










para descargar el programa fuente da click aqui

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

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í!!!!!