Escena Fractal

En este fractal se utilzan 3 metodos para dibujarlo, los cuales en 2 de ellos se usa recursividad. Abajo el codigo. El fractal se puede generar mediante un timer (automaticamente) o con un boton. Usted elige.


class TForm1 : public TForm
{
__published: // IDE-managed Components
        TPaintBox *PaintBox1;
        TButton *Button1;
        TTimer *Timer1;
        void __fastcall Button1Click(TObject *Sender);
        void __fastcall Timer1Timer(TObject *Sender);
private: // User declarations

void subdivide(int first, int last, double std, double ratio);
void fractal(int y1, int y2, int maxlevel, double h, double scale);
void draw_fractal(void);
public: // User declarations
        __fastcall TForm1(TComponent* Owner);
};


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

#include <vcl.h>
#include <math.h>
#pragma hdrstop

#include "EscenaFractal.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

const int MAXSIZE = 1000;
const int MAXLEVEL = 6;
double frct1[MAXSIZE];
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void TForm1::subdivide(int p1, int p2, double std, double ratio)
{
        int midpnt;
        double stdmid;

        midpnt = (p1 + p2) / 2;

        if(midpnt != p1 && midpnt != p2)
        {
          frct1[midpnt] = (frct1[p1] + frct1[p2]) / 2 +
          (double)((random(16) - 8)) / 8.0 * std;

          stdmid = std * ratio;

          subdivide(p1, midpnt, stdmid, ratio);
          subdivide(midpnt, p2, stdmid, ratio);
        }
}

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);
        frct1[first] = y1;
        frct1[last] = y2;
        ratio = 1.0 / pow(2.0,h);
        std = scale * ratio;
        subdivide(first, last, std, ratio);
}

void TForm1::draw_fractal(void)
{
        int i, x, xinc, l;
        //int cw = Form1->ClientWidth;

        l = (int)pow(2.0, (double)MAXLEVEL);
        xinc = ClientWidth / l * 3 / 2;
        Form1->Canvas->MoveTo(0, 100);

        for(i = 0, x = 0; i < l; i++, x +=xinc)
        {
          Form1->Canvas->LineTo(x, (int)frct1[i]);
        }

}
void __fastcall TForm1::Button1Click(TObject *Sender)
{
        randomize();
        PaintBox1->Refresh();
        PaintBox1->Canvas->Rectangle(0,0, PaintBox1->Width, PaintBox1->Height);
        PaintBox1->Canvas->Brush->Color = clSkyBlue;
        fractal(100,100, MAXLEVEL, 0.5, 50.0);
        draw_fractal();
        PaintBox1->Canvas->FloodFill(1,1, clBlack, fsBorder);

        PaintBox1->Canvas->Brush->Color = clBlue; //(TColor);
        fractal(170, 170, MAXLEVEL, 0.9, 30.0);
        draw_fractal();
        PaintBox1->Canvas->FloodFill(1, 240, clBlack, fsBorder);

        PaintBox1->Canvas->Brush->Color = clYellow; //;(TColor)SUN;
        PaintBox1->Canvas->Ellipse(250, 20, 290, 60);
        PaintBox1->Canvas->FloodFill(270, 50, clBlack, fsBorder);

        PaintBox1->Canvas->Brush->Color = clGreen;
        PaintBox1->Canvas->FloodFill(270, 150, clBlack, fsBorder);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
    randomize();
        PaintBox1->Refresh();
        PaintBox1->Canvas->Rectangle(0,0, PaintBox1->Width, PaintBox1->Height);
        PaintBox1->Canvas->Brush->Color = clSkyBlue;
        fractal(100,100, MAXLEVEL, 0.5, 50.0);
        draw_fractal();
        PaintBox1->Canvas->FloodFill(1,1, clBlack, fsBorder);

        PaintBox1->Canvas->Brush->Color = clBlue; //(TColor);
        fractal(170, 170, MAXLEVEL, 0.9, 30.0);
        draw_fractal();
        PaintBox1->Canvas->FloodFill(1, 240, clBlack, fsBorder);

        PaintBox1->Canvas->Brush->Color = clYellow; //;(TColor)SUN;
        PaintBox1->Canvas->Ellipse(250, 20, 290, 60);
        PaintBox1->Canvas->FloodFill(270, 50, clBlack, fsBorder);

        PaintBox1->Canvas->Brush->Color = clGreen;
        PaintBox1->Canvas->FloodFill(270, 150, clBlack, fsBorder);
}
//---------------------------------------------------------------------------

Fractal de Mandel

Codigo del fractal de Mandel. Fractal hecho a base de pixeles rojos. El codigo es muy corto y facil de
implementar, aqui abajo esta.


class TForm1 : public TForm
{
__published: // IDE-managed Components
        TTimer *Timer1;
        void __fastcall Timer1Timer(TObject *Sender);
private: // User declarations
public: // User declarations

int maxX, maxY, Limite, i, j, Pasos, Terminar;
double PasoX, PasoY, PosX, PosY, OrigX, OrigY,
DimX, DimY, IterX, IterY, TempX;

        __fastcall TForm1(TComponent* Owner);
};



void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
     maxX = ClientWidth;
     maxY = 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(Form1->OnKeyPress)
             {
                i = maxX;
                j = maxY;
                Terminar++;
             }
          }

          if(Pasos < Limite)
          {
            Canvas->Pixels[i][j] = clRed;
          }

        }
     }

}

Fractal de Henon

Codigo de fractal de Henon.



void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
        EscalaX = 1;
        EscalaY = 1;
        maxX = ClientWidth;
        maxY = ClientHeight;
        DespX = 0;
        DespY = 0;
        ExtranioConfinador();
        Sleep(100);
}
//---------------------------------------------------------------------------

void TForm1::ExtranioConfinador()
{
        int a, i, Color, PosX, PosY;
        double Xant, Xnuevo, Yant, Ynuevo;

        Xant = Xnuevo = Yant = Ynuevo = 0;

        for(Color = 1; Color <=5; Color++)
        {
           for(i = i; i <= 0x02FF; i++)
           {
              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) && (PosY <= maxX) && (PosY >= 0) && (PosY <= maxY))
              {
                Canvas->Pixels[PosX][PosY] = clRed;
              }

              Yant = Ynuevo;
              Xant = Xnuevo;
           }
        }

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

archivo .h

class TForm1 : public TForm

{

__published: // IDE-managed Components

        TButton *Button1;

        TTimer *Timer1;

        void __fastcall Timer1Timer(TObject *Sender);

        void __fastcall Button1Click(TObject *Sender);

private: // User declarations

public: // User declarations

        int maxX, maxY;

        double EscalaX, EscalaY, DespX, DespY;

        void ExtranioConfinador();

        __fastcall TForm1(TComponent* Owner);

};

Fractal del Dragon

En la imagen se ve el proceso que va tomando el codigo de este fractal. Abajo el codigo.



void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
        int i;
        Paso = 4096;
        Signo = -1;

        EjeX[1] = ClientWidth / 4;      //getmax
        EjeX[4097] = 3 * ClientWidth / 4;
        EjeY[1] = EjeY[4097] = 2 * ClientHeight / 3;
        randomize();

        Canvas->MoveTo(EjeX[1], EjeY[1]);
        Canvas->LineTo(EjeX[4097], EjeY[4097]);
       
        Sleep(1000);

        for(i = 1; i <= 13; i++)
        {
           //Repaint();
           Refresh();
           Canvas->TextOutA(5,5,"Curva fractal del dragon");
           GenerarDragon(TColor(RGB(random(256), 0 ,0)));
           Paso /= 2;
           Sleep(1000);
         
        }
        ///Sleep(10);
}
//---------------------------------------------------------------------------
 void TForm1::GenerarDragon(TColor color)
 {

        int i, j, dx, dy;
        j = Paso /2;

        Canvas->Pen->Color = color;
        Sleep(1000);

        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(100);
        }

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

 abajo archivo .h

class TForm1 : public TForm

{

__published: // IDE-managed Components

        TTimer *Timer1;

        TButton *Button1;

        TButton *Button2;

        void __fastcall Timer1Timer(TObject *Sender);

        void __fastcall Button1Click(TObject *Sender);

        void __fastcall Button2Click(TObject *Sender);

private:       // User declarations

void GenerarDragon(TColor color);

int EjeX[4098], EjeY[4098], Paso, Signo;

public: // User declarations

        __fastcall TForm1(TComponent* Owner);

};

Fractal de Newton-Raphson

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

#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

//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] = 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 ====================================================---------------------------------------------------------------------

Como hacer zoom en una imagen bmp en c++

Codigo para hacer zoom en una imagen. El codigo es corto y facil. 

void __fastcall TForm1::Image1MouseDown(TObject *Sender,

      TMouseButton Button, TShiftState Shift, int X, int Y)

{

        x1 = X;         // coordenadas del click

        y1 = Y;        

}

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

void __fastcall TForm1::Image1MouseUp(TObject *Sender, TMouseButton Button,

      TShiftState Shift, int X, int Y)

{

         x2 = X;       // coordenadas cuando se suelta el click del mouse

         y2 = Y;

         TRect origen, destino;

         

         origen = Rect(x1, y1, x2, y2);  // area del rectangulo donde quiero hacer zoom

         destino = Rect(0, 0, Image2->Width, Image2->Height); // rectangulo donde se va a copiar

         Image2->Canvas->CopyRect(destino, Image1->Canvas, origen);  // zoom de la imagen

}

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

Manipulacion de pixeles en una imagen bmp

En este programa aprendimos como manejar la matriz de pixeles usando la mascara para el corrimiento de
los bits y asi poder cambiar el color de la imagen ya sea rojo, verde o azul. Tambien utilizamos la matriz
de pixeles para cambiar la posicion de la imagen. Abajo esta el codigo.


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

        TColor color;

        for(int y = 0; y < Image1->Height; y++)
        {
           for(int x = 0; x < Image1->Width; x++)
           {
              color = Image1->Canvas->Pixels[x][y];
              color = color & 255;

              Image2->Canvas->Pixels[x][y] = color;
           }
        }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn2Click(TObject *Sender)
{
        TColor color;
        int mascara = 255;

        mascara = mascara << 8;

        for(int y = 0; y < Image1->Height; y++)
        {
           for(int x = 0; x < Image1->Width; x++)
           {
              color = Image1->Canvas->Pixels[x][y];
              color = color + mascara;

              Image2->Canvas->Pixels[x][y] = color;
           }
        }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn3Click(TObject *Sender)
{
        TColor color;
        int mascara = 255;

        mascara = mascara << 16;

        for(int y = 0; y < Image1->Height; y++)
        {
           for(int x = 0; x < Image1->Width; x++)
           {
              color = Image1->Canvas->Pixels[x][y];
              color = color + mascara;

              Image2->Canvas->Pixels[x][y] = color;
           }
        }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
        //Image3->Picture->LoadFromFile("santos laguna.bmp");
        //Image3->Height = Image2-> Width - 3;
        //Image3->Width = Image2-> Height - 3;
        TColor color;

        for(int x = 0; x < Image1->Width; x++)
        {
           for(int y = 0; y < Image1->Height; y++)
           {
             color = Image1->Canvas->Pixels[x][y];
             Image3->Canvas->Pixels[Image1->Width - x][y] = color;
           }
        }


}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)
{
        TColor color;

        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] = color;
           }
        }

}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)
{
        TColor color;

        for(int x = 0; x < Image1->Width; x++)
        {
           for(int y = 0; y < Image1->Height; y++)
           {
             color = Image1->Canvas->Pixels[x][y];
             Image3->Canvas->Pixels[Image1->Width - x][Image1->Height - y] = color;
           }
        }
}
//---------------------------------------------------------------------------

El futuro de la tecnologia de pantallas

Este video que encontre en youtube nos muestra como muy pronto van a ser los dispositivos que tienen una pantalla en un futuro cercano. Hace unos años los creiamos casi imposibles pues solo los veiamos en peliculas de ciencia ficcion y en caricaturas. Ahora, es algo que sucedera en muy poco tiempo por el gran avance de la tecnologia. Espero y les guste.

http://www.youtube.com/watch?v=g7_mOdi3O5E&feature=player_embedded

Programa manipulacion de colores

void __fastcall TForm1::RojoChange(TObject *Sender)
{
   Panel1->Color = (TColor)RGB(Rojo->Position, Verde->Position, Azul->Position);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn1Click(TObject *Sender)
{

       for(int i = 0; i < 1000; i++)
       {
         Image1->Canvas->Pixels[random(Image1->Width)][random(Image1->Height)]
          = (TColor)RGB(random(180)+175, 0, 0);
       }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BitBtn2Click(TObject *Sender)
{
      for(int i = 0; i < 1000; i++)
       {
         Image1->Canvas->Pixels[random(Image1->Width)][random(Image1->Height)]
          = (TColor)RGB(0, random(180)+175, 0);
       }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::BitBtn3Click(TObject *Sender)
{
       for(int i = 0; i < 1000; i++)
       {
         Image1->Canvas->Pixels[random(Image1->Width)][random(Image1->Height)]
          = (TColor)RGB(0, 0, random(180)+175);
       }
}
//---------------------------------------------------------------------------

Este programa que hicismos en clase es mas facil de lo que parece. Espero y les guste.