Para seguir con la graficación, en esta ocasión complementaremos un poco mas el ejercicio realizado en la entrada anterior para lograr 4 planos dentro de la forma, y que dentro de cada plano exista un movimiento de puntos hacia el centro de dichos planos, y para poder diferenciarlos los realizaremos con colores diferentes.
El ejercicio lo vamos a hacer tanto en lenguaje C++ como en C#, para que puedan apreciar las pequeñas variantes que existen entre dichos lenguajes, en cuanto a código.
La forma solamente solamente estaría compuesta por cuatro Timers sobre ella, uno para cada plano, y pondremos el fondo de la forma en color negro, para que se distingan mas los colores de cada pixel (ésto es opcional).
Entonces la forma diseñada en Borland C++ Builder quedaría de la siguiente manera:
Y la forma diseñada en C# seria la siguiente, igual con 4 Timers(Son Invisibles en VS):
Entonces el código en c++ quedaria de la siguiente manera:
EN C++:
En el .h:
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
TTimer *Timer1;
TTimer *Timer2;
TTimer *Timer3;
TTimer *Timer4;
void __fastcall FormPaint(TObject *Sender);
void __fastcall Timer1Timer(TObject *Sender);
void __fastcall Timer2Timer(TObject *Sender);
void __fastcall Timer3Timer(TObject *Sender);
void __fastcall Timer4Timer(TObject *Sender);
void __fastcall FormResize(TObject *Sender);
private: // User declarations
public: // User declarations
POINT Puntos1[1000]; // Matriz para mantener la posición de 1000 puntos en el cuadrante 1
POINT Puntos2[1000]; // Matriz para mantener la posición de 1000 puntos en el cuadrante 2
POINT Puntos3[1000]; // Matriz para mantener la posición de 1000 puntos en el cuadrante 3
POINT Puntos4[1000]; // Matriz para mantener la posición de 1000 puntos en el cuadrante 4
int Contador; // Contador general para la matriz anterior
int MediaX1, MediaY1, MediaX2, MediaY2, MediaX3, MediaY3, MediaX4, MediaY4;
// Punto medio de cada área de dibujo o plano
__fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
En el .cpp:
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;//
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormPaint(TObject *Sender) //Llamada al evento FormPaint, para dibujar los 4
//Planos (Rectangulos) en la forma
{
randomize(); //Método para activar la funcion aleatoria
Canvas->Pen->Color = (TColor) RGB(0,255,0); // Asignamos un color verde a la pluma de dibujo
Canvas->Rectangle(0,0,this->ClientWidth/2,this->ClientHeight/2); //Dibujamos el primer rectangulo //ubcado en la parte superior izquierda de la forma
Canvas->Pen->Color = (TColor) RGB(255,0,0);//Asignamos un color rojo a la pluma de dibujo
Canvas->Rectangle(this->ClientWidth/2,0,this->ClientWidth,this->ClientHeight/2);//Dibujamos el //segundo rectangulo ubicado en la parte superior derecha de la forma
Canvas->Pen->Color = (TColor) RGB(0,0,255);//Asignamos un color azul a la pluma de dibujo
Canvas->Rectangle(0, this->ClientHeight/2,this->ClientWidth / 2,this->ClientHeight);//Dibujamos el //tercer rectangulo, ubicado en la parte inferior izquierda de la forma
Canvas->Pen->Color =(TColor) RGB(255,0,255);//Asignamos un color rosa a la pluma de dibujo
Canvas->Rectangle(this->ClientWidth/2,this->ClientHeight/2,this->ClientWidth,this->ClientHeight);
//Dibujamos el cuarto, rectangulo, ubicado en la parte inferior derecha de la forma
for(int N = 0; N < 1000; N++)
{ // Calcular los 1000 puntos de forma aleatoria en cada plano
int r1, r2;
//Primer Plano (Superior-Izquierdo)
r1 = random(ClientWidth / 2); //Cuyo valor en X no rebase la mitad del ancho de la forma
r2 = random(ClientHeight / 2);//Cuyo valor en Y no rebase la mitad del largo de la forma
Puntos1[N].x = r1; //Y asignamos los valores obtenidos para posicionar cada punto
Puntos1[N].y = r2;
Canvas->Pixels[Puntos1[N].x][Puntos1[N].y] = clRed;//y los dibujamos con un color rojo
//Segundo plano (Superior-Derecho)
r1 = random(ClientWidth);//Cuyo valor en X puede abarcar todo el ancho de la forma
r2 = random(ClientHeight / 2);//Cuyo valor en Y no rebase la mitad del largo de la forma
while(r1<ClientWidth / 2) r1 = random(ClientWidth);//Mientras el valor en X sea menor que la mitad
//del ancho de la forma, se vuelve a calcular dicho valor.
Puntos2[N].x = r1; //Y asignamos los valores obtenidos para posicionar cada punto
Puntos2[N].y = r2;
Canvas->Pixels[Puntos2[N].x][Puntos2[N].y] = clPurple;//Y asi dibujarlos con un color morado
// Hacemos lo mismo para el tercer plano(Inferior-Izquierdo)
r1 = random(ClientWidth / 2);
r2 = random(ClientHeight);
while(r2 < ClientHeight / 2) r2 = random(ClientHeight); //Mientras el valor de X sea menor que la
//mitad del largo de la forma, se vuelve a calcular dicho valor
Puntos3[N].x = r1;
Puntos3[N].y = r2;
Canvas->Pixels[Puntos3[N].x][Puntos3[N].y] = clSkyBlue;// y dibujamos cada punto en un color //azul cielo
//Y por utlimo en el cuarto plano (Inferior-Derecho)
do
{
r1 = random(ClientWidth); //vamos a calcular X y Y del punto tomando como referencia todo
r2 = random(ClientHeight);//el largo y ancho de la forma
}
while(r1 < ClientWidth / 2 || r2 < ClientHeight / 2);//mientras X sea inferior a la mitad del ancho
//de la forma o Y sea inferior al largo de la forma, se vuelven a calcular
Puntos4[N].x = r1;
Puntos4[N].y = r2;
Canvas->Pixels[Puntos4[N].x][Puntos4[N].y] = clGreen;//Y se dibujan en color verde
}
Contador = 0; // Inicializar el contador
MediaX1 = (ClientWidth / 4); //Y calculamos el punto medio del primer plano
MediaY1 = (ClientHeight / 4);
MediaX2 = (ClientWidth / 4) * 3; //Y calculamos el punto medio del segundo plano
MediaY2 = (ClientHeight / 4);
MediaX3 = (ClientWidth / 4); //Y calculamos el punto medio del tercer plano
MediaY3 = (ClientHeight / 4) * 3;
MediaX4 = (ClientWidth / 4) * 3; //Y calculamos el punto medio del cuarto y ultimo plano
MediaY4 = (ClientHeight / 4) * 3;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)//Aqui moveremos los pixeles del primer plano
{
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[Puntos1[Contador].x][Puntos1[Contador].y] = clBlack;
// Calcular su nueva posición
Puntos1[Contador].x += (Puntos1[Contador].x < MediaX1)*1 + (Puntos1[Contador].x > MediaX1)*-1;
Puntos1[Contador].y += (Puntos1[Contador].y < MediaY1)*1 + (Puntos1[Contador].y > MediaY1)*-1;
// Si el punto está en el centro del área debe desaparecer
if (Puntos1[Contador].x == MediaX1 && Puntos1[Contador].y == MediaY1)
{
// Reapareciendo en un punto aleatorio
Puntos1[Contador].x = random(ClientWidth / 2);
Puntos1[Contador].y = random(ClientHeight / 2);
}
// Mostrarlo en la nueva posición
Canvas->Pixels[Puntos1[Contador].x][Puntos1[Contador].y] = clRed;//Black;
Contador++; // Pasar al punto siguiente
// O al primero si ya se han recorrido todos
if (Contador == 1000)
Contador = 0;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer2Timer(TObject *Sender)//Mover los puntos en el segundo plano
{
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[Puntos2[Contador].x][Puntos2[Contador].y] = clBlack;
// Calcular su nueva posición
Puntos2[Contador].x += (Puntos2[Contador].x < MediaX2)*1 + (Puntos2[Contador].x > MediaX2)*-1;
Puntos2[Contador].y += (Puntos2[Contador].y < MediaY2)*1 + (Puntos2[Contador].y > MediaY2)*-1;
// Si el punto está en el centro del área debe desaparecer
if (Puntos2[Contador].x == MediaX2 && Puntos2[Contador].y == MediaY2)
{
// Reapareciendo en un punto aleatorio
Puntos2[Contador].x = (ClientWidth / 2) + random(ClientWidth / 2);
Puntos2[Contador].y = random(ClientHeight / 2);
}
// Mostrarlo en la nueva posición
Canvas->Pixels[Puntos2[Contador].x][Puntos2[Contador].y] = clPurple;//Black;
Contador++; // Pasar al punto siguiente
// O al primero si ya se han recorrido todos
if (Contador == 1000)
Contador = 0;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer3Timer(TObject *Sender) //Mover puntos en el tercer plano
{
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[Puntos3[Contador].x][Puntos3[Contador].y] = clBlack;
// Calcular su nueva posición
Puntos3[Contador].x += (Puntos3[Contador].x < MediaX3)*1 + (Puntos3[Contador].x > MediaX3)*-1;
Puntos3[Contador].y += (Puntos3[Contador].y < MediaY3)*1 + (Puntos3[Contador].y > MediaY3)*-1;
// Si el punto está en el centro del área debe desaparecer
if (Puntos3[Contador].x == MediaX3 && Puntos3[Contador].y == MediaY3)
{
// Reapareciendo en un punto aleatorio
Puntos3[Contador].x = random(ClientWidth / 2);
Puntos3[Contador].y = (ClientHeight / 2) + random(ClientHeight / 2);
}
// Mostrarlo en la nueva posición
Canvas->Pixels[Puntos3[Contador].x][Puntos3[Contador].y] = clSkyBlue;//Black;
Contador++; // Pasar al punto siguiente
// O al primero si ya se han recorrido todos
if (Contador == 1000)
Contador = 0;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer4Timer(TObject *Sender) //Mover puntos en el cuarto plano
{
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[Puntos4[Contador].x][Puntos4[Contador].y] = clBlack;
// Calcular su nueva posición
Puntos4[Contador].x += (Puntos4[Contador].x < MediaX4)*1 + (Puntos4[Contador].x > MediaX4)*-1;
Puntos4[Contador].y += (Puntos4[Contador].y < MediaY4)*1 + (Puntos4[Contador].y > MediaY4)*-1;
// Si el punto está en el centro del área debe desaparecer
if (Puntos4[Contador].x == MediaX4 && Puntos4[Contador].y == MediaY4)
{
// Reapareciendo en un punto aleatorio
Puntos4[Contador].x = (ClientWidth / 2) + random(ClientWidth / 2);//p41
Puntos4[Contador].y = (ClientHeight / 2) + random(ClientHeight / 2);//p42
}
// Mostrarlo en la nueva posición
Canvas->Pixels[Puntos4[Contador].x][Puntos4[Contador].y] = clGreen;//Black;
Contador++; // Pasar al punto siguiente
// O al primero si ya se han recorrido todos
if (Contador == 1000)
Contador = 0;
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormResize(TObject *Sender)
{
this->Refresh(); //Cada vez que la forma cambie de dimensión el programa comenzara desde el inicio
}
//---------------------------------------------------------------------------
Ahora que conocemos el programa en c++, procederemos a realizar su equivalente en C#
El codigo en C# es el siguiente:
Y los resultados tanto en C# como en C++ son los siguientes:
C++:
C#:
Esto fue todo por hoy, espero que les haya sido por lo menos un poco util.
Proximamente mostraremos programas mas complejos y evoluciones de lo que hoy presentamos para llevar un desarrollo evolutivo en cuanto a nuestros conocimientos de graficacion.
Nos vemos pronto.
No hay comentarios:
Publicar un comentario