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

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

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 

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