Bienvenidos

En este blog se publicaran proyectos en c++, les doy la bienvenida y espero sea de ayuda para ustedes este espacio, no olviden comentar!

domingo, 20 de noviembre de 2011

Efecto de Nieve Usando Pixeles en Movimiento en C++

El siguiente programa simula la caída de nieve . El programa es muy simple, solo se hace uso de pixeles en movimiento y formas sencillas como la elipse para dibujos circulares. Dibuje un muñeco de nieve en la escena con motivo de navidad.


 El programa ejecutándose se muestra en la imagen:




Les muestro los componentes de la forma 
2 Timer 
11 PaintBox

El dibujado del muñeco se hizo sobre los PaintBox.
Este es el código del dibujado del muñeco, tengan en cuenta que el orden de los PaintBox en la forma dibujaran círculos y deben coincidir para formar el muñeco:
Todo este código va sobre un Timer 



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


  this->Canvas->Brush->Color=clSilver+random(40);
  this->Canvas->Ellipse(10,10,110,110);


  PaintBox4->Canvas->Brush->Color=clMaroon;
  PaintBox5->Canvas->Brush->Color=clMaroon;
  PaintBox4->Canvas->Rectangle(0,0,PaintBox4->Width, PaintBox4->Height);
  PaintBox5->Canvas->Rectangle(0,0,PaintBox5->Width, PaintBox5->Height);


  PaintBox1->Canvas->Brush->Color=clWhite;
  PaintBox2->Canvas->Brush->Color=clWhite;
  PaintBox3->Canvas->Brush->Color=clWhite;




  PaintBox1->Canvas->Pen->Color=clWhite;
  PaintBox2->Canvas->Pen->Color=clWhite;
  PaintBox3->Canvas->Pen->Color=clWhite;


  PaintBox1->Canvas->Ellipse(0,0,PaintBox1->Width, PaintBox1->Height);
  PaintBox2->Canvas->Ellipse(0,0,PaintBox2->Width, PaintBox2->Height);
  PaintBox3->Canvas->Ellipse(0,0,PaintBox3->Width, PaintBox3->Height);


  PaintBox6->Canvas->Brush->Color=clBlack;
  PaintBox7->Canvas->Brush->Color=clBlack;
  PaintBox8->Canvas->Brush->Color=clBlack;
  PaintBox9->Canvas->Brush->Color=clBlack;


  PaintBox6->Canvas->Ellipse(0,0,PaintBox6->Width, PaintBox6->Height);
  PaintBox7->Canvas->Ellipse(0,0,PaintBox7->Width, PaintBox7->Height);
  PaintBox8->Canvas->Ellipse(0,0,PaintBox8->Width, PaintBox8->Height);
  PaintBox9->Canvas->Ellipse(0,0,PaintBox9->Width, PaintBox9->Height);




  PaintBox10->Canvas->Pen->Color=clBlack;
  PaintBox10->Canvas->Pen->Width=5;


  PaintBox11->Canvas->Pen->Color=clBlack;
  PaintBox11->Canvas->Pen->Width=5;


  PaintBox10->Canvas->MoveTo(0,PaintBox10->Height);
  PaintBox10->Canvas->LineTo(PaintBox10->Width,0);


  PaintBox11->Canvas->MoveTo(PaintBox11->Width, PaintBox11->Height);
  PaintBox11->Canvas->LineTo(0,0);
}

  
Para dibujar la nieve inicializamos las variables en el .h 



private:
// User declarations
    POINT Puntos[1000];//Para mantener la posición de 1000 puntos
    int Contador; // Contador general para la matriz anterior
    int MediaX, MediaY; // Punto medio del área de dibujo
    POINT Nieve[1000];



Nos vamos al evento FormPaint y ponemos las posicio iniciales de los puntos o pixeles



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
      MediaX = ClientWidth ; // Y calcular el punto medio
      MediaY = ClientHeight ;
}



Ahora el movimiento de los pixeles se pone en el otro Timer, se agrego una breve descripción de lo que hace el código 



void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
  for (int N = 0; N < 10000; 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] = clNavy;
    // Calcular su nueva posición
    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);


    }


     // Mostrarlo en la nueva posición
     Canvas->Pixels[Puntos[Contador].x][Puntos[Contador].y] = clWhite;//Black;
     Contador++; // Pasar al punto siguiente
     //O al primero si ya se han recorrido todos
    if (Contador == 1000)
      Contador = 0;
   }


}

Al ejecutar el programa se observa que la nieve se mueve de forma diagonal.
El código del muñeco se puede omitir sin afectar el funcionamiento del programa.
El fin de este programa fue manipular los pixeles en c++. Para ver el uso de pixeles en c# vayan la publicación donde esta el juego de la serpiente en este mismo blog.
Próximamente se subirán mas ejemplos con pixeles también programación en 3D.

Comenten y den sugerencias GRACIAS! 

viernes, 18 de noviembre de 2011

Transformaciones en 2D con multiplicaciones de matrices(Escalacion, Traslación, Rotación y Reflexión)

El siguiente programa muestra las transformaciones que se le pueden dar a un dibujo en 2D utilizando coordenadas homogéneas. En el siguiente programa se manipula un triangulo, un gato y un helicóptero. Las transformaciones se llevan a cabo utilizando matrices de coordenadas y matrices de transformación dependiendo de la transformación(escalacion, traslación, rotación y reflexión)  que se vaya a hacer.


PROGRAMA EN C++ PARA TRANSFORMACIONES
Aquí les muestro un sencillo programa que dibuja tres diferentes formas(triangulo, gato, helicóptero) 

La ESCALACION de una de las figuras se muestra en las siguientes imágenes, se usan dos datos uno para la ampliación de la imagen en el eje x y otro para la ampliación en y(Generalmente usamos el mismo dato paro no perder la forma de la figura).

Objeto Normal





















Objeto Escalado 





















Ahora vamos a trasladar el objeto hacia la izquierda, es decir, -x y dejándolo en la misma posición con respecto a y, y=0(no hay movimiento en el eje y).






















Ahora vamos a ROTAR una figura utilizando un punto de rotación con respecto a la figura y dándole un angulo de rotación. En la siguiente figura se muestra el triangulo con rotaciones de 45 grados . Como se puede observar se forma un octágono al girar el triangulo.
























Ahora Rotamos el Gato 0 grados
30 grados


La REFLEXIÓN se hace con respecto a los ejes:
Por ejemplo con respecto al eje X o con respecto al eje Y. En la imagen se hizo la reflexión de la figura primero con respecto al eje X luego con el eje Y y de nuevo con el eje X formando reflexión en los 4 cuadrantes.


También respecto al eje coordenado



Ahora veamos como se realizo la interfaz gráfica































Para llevar a Cabo Las Transformaciones Agregamos una clase Matrix con el siguiente código:
Código en el .h de la clase Matrix que muestra todos los métodos que usaremos
//-------------------------------------------------------------//


#ifndef MatrixH
#define MatrixH
//------------------------------------------------------------//
class Matrix
{
   int col, ren;
   float **Mat;


public:
   Matrix();
   Matrix(Matrix &);
   ~Matrix();
   void SETM(int R, int C, float val){Mat[R][C]=val;}
   float GETM(int R, int C){return Mat[R][C];}
   int numCol(){return col;}
   int numRen(){return ren;}
   void Inicializa(int, int);
   Matrix &operator *=(Matrix &mat2);
   Matrix operator*(float);//Multiplicar por un escalar
   //Matrix & operator =(Matrix &mat2);
   Matrix & Identidad();
   Matrix & operator=(Matrix &m);
   Matrix & asignar(Matrix);
   Matrix & traslacion(Matrix,Matrix,int,int);
   Matrix & escalacion(Matrix,Matrix,int,int);
   Matrix & escalacionpos(Matrix,Matrix,float,float,int,int);
  Matrix &Matrix:: rotacion(Matrix ,Matrix ,float ,float ,float);
   Matrix &Matrix:: Reflexion(Matrix, Matrix, int);


};
#endif


Ahora el código que va en el .ccp donde se definen los métodos y constructores necesarios.

/---------------------------------------------------------------------------
#pragma hdrstop
#include "Matrix.h"
#include <math.h>
#include <assert.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
//Constructor de la matriz
Matrix::Matrix()
{
   Mat = NULL;
}

//Inicializa una matriz con con otra matriz
Matrix::Matrix(Matrix &m)
{
   ren=m.numRen();
   col=m.numCol();
   Mat =new float*[ren];
   for(int i = 0; i < ren; i++)
  {
     Mat[i] = new float[col];
     assert(Mat[i]);
  }
   for(int i=0; i<ren; i++)
      for( int j=0; j<col; j++)
         Mat[i][j]=m.GETM(i,j);
}
//Inicializa dandole un tamaño(numero de renglones y columnas)
void Matrix::Inicializa(int R, int C)
{
   col=C;
   ren=R;
   Mat=new float *[ren];
   for(int i=0; i<ren; i++)
      Mat[i]=new float[col];
   for(int i=0; i<ren; i++)
      for(int j=0; j<col; j++)
         Mat[i][j]=0;//Siempre se inician con ceros
}
//Sobrecarga del operador *= para multiplicar objetos del tipo
//Matriz
Matrix &Matrix::operator*=(Matrix &mat2)
{
   Matrix aux;
   aux.Inicializa(ren, mat2.numCol());


   for(int i=0; i<ren; i++)
   {
      for(int j=0; j<mat2.numCol(); j++)
      {
         float suma=0;
         for(int k=0; k<col; k++)
         {
           suma+=floor(Mat[i][k]*mat2.GETM(k,j)+0.5);//Multiplica
                                    
           aux.SETM(i,j,suma);//Guarda todo en un auxiliar
         }
      }
   }
   asignar(aux);
   return *this;//Regresa el resultado
}
//Sobrecarga del operador * para objetos del tipo Matrix
Matrix Matrix::operator*(float val)
{
   Matrix temp;
   temp.Inicializa(ren,col);
   for(int i=0; i<ren;i++)
      for(int j=0; j<col; j++)
         temp.SETM(i,j,Mat[i][j]* val);
   return temp;
}

//Sobrecarga del operador =
Matrix &Matrix::operator=(Matrix &m)
{
//eliminar el tamaño de la matriz destino
  for(int i= 0; i<ren;i++ )
     //Se borran los renglones de la matriz
       delete [] Mat[i];
  //Se borra el arreglo de punteros
  delete []Mat;
//Asignar los nuevos datos de la matriz que llego
  ren=m.numRen();
  col = m.numCol();
  Mat = new float*[ren];
  assert(Mat);
  for(int i = 0; i < ren; i++)
  {
     Mat[i] = new float[col];
     assert(Mat[i]);
  }
  for( int i =0; i < ren; i++)
    for(int j = 0; j < col; j++)
        Mat[i][j] = m.Mat[i][j];

  return *this;
}
//Otra forma de sobrecargar

/*Matrix &Matrix::operator =(Matrix &mat2)
{
    ren=mat2.numRen();
    col=mat2.numCol();
    for(int i=0;i<ren;i++)
       for(int j=0;j<col;j++)
          Mat[i][j]=mat2.GETM(i,j);
    return *this;
} */

Matrix &Matrix::asignar(Matrix m)
{
   for(int i=0;i<m.numRen();i++)
       for(int j=0;j<m.numCol();j++)
                Mat[i][j]=m.GETM(i,j);
   return *this;
}
//Desructor
Matrix::~Matrix()
{
  //Se libera la memoria
  for(int i= 0; i<ren;i++ )
     //Se borran los renglones de la matriz
       delete [] Mat[i];
  //Se borra el arreglo de punteros
  delete []Mat;

}
//crea una Matriz identidad o escalonada
Matrix &Matrix::Identidad()
{
  for(int i=0; i < ren; i++)
    for( int j = 0; j < col; j++)
      if( i == j)
         Mat[i][i]= 1;
      else
         Mat[i][j]= 0;
  return *this;
}
//---------MÉTODOS DE TRANSFORMACIÓN-----------------------//
Matrix & Matrix::traslacion(Matrix f,Matrix id,int tx,int ty)
{
   id.Identidad();
   id.SETM(2,0,tx);
   id.SETM(2,1,ty);

   f*=id;

   this -> asignar(f);
   return *this;

}

Matrix & Matrix::escalacion(Matrix f,Matrix id,int sx,int sy)
{
   id.Identidad();
   id.SETM(0,0,sx);
   id.SETM(1,1,sy);

   f*=id;

   asignar(f);
   return *this;

}
Matrix & Matrix::escalacionpos(Matrix f,Matrix id,float sx,float sy,int tx, int ty)
{
   float fx=tx*(-sx+1);
   float fy=ty*(-sy+1);

   id.Identidad();
   id.SETM(2,0,fx);
   id.SETM(2,1,fy);

   id.SETM(0,0,sx);
   id.SETM(1,1,sy);

  
   f*=id;

   this->asignar(f);
   return *this;
}

Matrix &Matrix:: rotacion(Matrix f,Matrix id,float M,float N,float angulo)
{
   id.Identidad();
   float ang = angulo*M_PI/180.0;
   float r20= -M*(cos(ang)-1)+N*sin(ang);
   float r21= -N*(cos(ang)-1)-M*sin(ang);

   id.SETM(0,0,cos(ang));
   id.SETM(0,1,sin(ang));
   id.SETM(1,0,-sin(ang));
   id.SETM(1,1,cos(ang));
   id.SETM(2,0,r20);
   id.SETM(2,1,r21);

   f*=id;

   asignar(f);
   return *this;

}


Matrix &Matrix:: Reflexion(Matrix f,Matrix id, int r)
{
    id.Identidad();
    if(r==1)
    {
    id.SETM(1,1,-1);
    }
    else if(r==2)
         id.SETM(0,0,-1);
         else if(r==3)
         {
           id.SETM(0,0,-1);
           id.SETM(1,1,-1);
         }
         else if(r==4)
         {
          id.SETM(0,0,0);
          id.SETM(1,1,0);
          id.SETM(1,0,1);
          id.SETM(0,1,1);
         }
         else if(r==5)
         {
          id.SETM(0,0,0);
          id.SETM(1,1,0);
          id.SETM(1,0,-1);
          id.SETM(0,1,-1);
         }

    f*=id;

    asignar(f);
    return *this;

}

Ahora va el código principal donde programamos nuestros componentes.
Primero el Codigo de .h de nuestro proyecto.
Solo agregamos las variables globales que usaremos en la parte donde esta la palabra private:
los componentes se generan automáticamente.



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

#ifndef Unit1H
#define Unit1H
//-------------------------------------------------------------//
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include <ComCtrls.hpp>
//-------------------------------------------------------------//
class TForm1 : public TForm
{
__published: // IDE-managed Components
        TGroupBox *GroupBox1;
        TButton *Button1;
        TButton *Button2;
        TEdit *Edit1;
        TEdit *Edit2;
        TPanel *Panel1;
        TButton *Button3;
        TUpDown *UpDown1;
        TEdit *Edit3;
        TEdit *Edit4;
        TUpDown *UpDown2;
        TLabel *Label1;
        TLabel *Label2;
        TButton *Button4;
        TPanel *Panel2;
        TButton *Button5;
        TEdit *Edit5;
        TEdit *Edit6;
        TLabel *Label3;
        TLabel *Label4;
        TUpDown *UpDown3;
        TUpDown *UpDown4;
        TEdit *Edit7;
        TEdit *Edit8;
        TUpDown *UpDown5;
        TUpDown *UpDown6;
        TEdit *Edit9;
        TLabel *Label5;
        TLabel *Label6;
        TLabel *Label7;
        TPanel *Panel3;
        TButton *Button6;
        TGroupBox *GroupBox2;
        TRadioButton *RadioButton1;
        TRadioButton *RadioButton2;
        TRadioButton *RadioButton3;
        TRadioButton *RadioButton4;
        TRadioButton *RadioButton5;
        TLabel *Label8;
        TLabel *Label9;
        TTimer *Timer1;
        TButton *Button7;
        TButton *Button8;
        void __fastcall FormPaint(TObject *Sender);
        void __fastcall Button2Click(TObject *Sender);
        void __fastcall Button1Click(TObject *Sender);
        void __fastcall Button3Click(TObject *Sender);
        void __fastcall Button4Click(TObject *Sender);
        void __fastcall FormCreate(TObject *Sender);
        void __fastcall Button5Click(TObject *Sender);
        void __fastcall Button6Click(TObject *Sender);
        void __fastcall Timer1Timer(TObject *Sender);
        void __fastcall Button7Click(TObject *Sender);
        void __fastcall UpDown2Click(TObject *Sender, TUDBtnType Button);
        void __fastcall UpDown1Click(TObject *Sender, TUDBtnType Button);
        void __fastcall Button8Click(TObject *Sender);
private: // User declarations
         //Variables definidas por nosotros
         int Fig[4][3];
         int FigAux[4][3];
         int FigGat[34][3];
         int FigGatAux[34][3];
         int Ojo1[5][3];
         int Ojo2[5][3];
         int Boca[4][3];
         int Tx, Ty;
public: // User declarations
        __fastcall TForm1(TComponent* Owner);
};
//-------------------------------------------------------------//
extern PACKAGE TForm1 *Form1;
//-------------------------------------------------------------//
#endif

El siguiente código es el que programamos para hacer uso de la clase Matrix y la implementamos para las transformaciones este código va en el Unit que sale al crear nuestro proyecto.



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


#include <vcl.h>
#pragma hdrstop
#include "Mapeo.h"
#include "Matrix.h"//Agregamos el include de nuestra clase
                   //Para usar sus métodos
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
 bool band;
//DIBUJAMOS LAS LINEAS PARA LOS EJES X, Y
void __fastcall TForm1::FormPaint(TObject *Sender)
{
   //LINEA HORIZONTAL
   Canvas->Pen->Width=2;
   Canvas->Pen->Color=clWhite;
   Canvas->MoveTo(0,Form1->ClientHeight/2);
   Canvas->LineTo(Form1->Width-Panel1->ClientWidth,Form1->ClientHeight/2);
   //LINEA VERTICAL
   Canvas->MoveTo((Form1->ClientWidth-Panel1->Width)/2,0);
   Canvas->LineTo((Form1->ClientWidth-Panel1->Width)/2,Form1->ClientHeight);
   Canvas->Pen->Color=clAqua;
}
//---------------------------------------------------------------------------


void __fastcall TForm1::Button2Click(TObject *Sender)
{
   band=true;
  // Form1->Refresh();
   int ancho = Panel1->Width;
   int L = (Form1->ClientWidth-ancho)/2;
   int M = Form1->ClientHeight/2;
   Fig[0][0]= 10; Fig[0][1]= 10; Fig[0][2]= 1;
   Fig[1][0]= 30; Fig[1][1]= 10; Fig[1][2]= 1;
   Fig[2][0]= 10; Fig[2][1]= 30; Fig[2][2]= 1;
   Fig[3][0]= 10; Fig[3][1]= 10; Fig[3][2]= 1;


  //respaldar valores
  for(int i=0; i<4; i++)
    for(int j=0; j<3; j++)
       FigAux[i][j]=Fig[i][j];


  UnidadII obj;
  obj.ventana((Form1->ClientWidth-ancho)/2,0,(Form1->ClientWidth-ancho),Form1->ClientHeight/2);
  obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,(Form1->ClientWidth-ancho),Form1->ClientHeight/2);


  int x, y;
  obj.mapeo(Fig[0][0], Fig[0][1], x, y,L, M);
  Canvas->MoveTo(x,y);
  for(int i=0; i<4; i++)
     {
      obj.mapeo(Fig[i][0],Fig[i][1], x, y, L, M);
      Canvas->LineTo(x,y);
     }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
   Form1->Refresh();
   int tx= Edit1->Text.ToIntDef(0);
   int ty= Edit2->Text.ToIntDef(0);
   int ancho = Panel1->Width;


   Matrix fig,id,fres;
   if(band==true)
   {
      fig.Inicializa(4,3);
      id.Inicializa(3,3);
      fres.Inicializa(4,3);


      for(int i=0;i<fig.numRen();i++)
         for(int j=0;j<fig.numCol();j++)
             fig.SETM(i,j,Fig[i][j]);


      fres.traslacion(fig,id,tx,ty);
      int L = (Form1->ClientWidth-ancho)/2;
      int M = Form1->ClientHeight/2;
      UnidadII obj;
      obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      int x,y;


      obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
      Canvas->MoveTo(x,y);
      for(int i=0; i<fres.numRen(); i++)
      {
         obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
         Canvas->LineTo(x, y);
      }
      for(int i=0;i<fres.numRen();i++)
         for(int j=0;j<fres.numCol();j++)
             Fig[i][j]=fres.GETM(i,j);


   }
   else if(band==false)
    {
      fig.Inicializa(34,3);
      id.Inicializa(3,3);
      fres.Inicializa(34,3);


      for(int i=0;i<fig.numRen();i++)
         for(int j=0;j<fig.numCol();j++)
             fig.SETM(i,j,FigGat[i][j]);


      fres.traslacion(fig,id,tx,ty);
      int L = (Form1->ClientWidth-ancho)/2;
      int M = Form1->ClientHeight/2;
      UnidadII obj;
      obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      int x,y;


      obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
      Canvas->MoveTo(x,y);
      for(int i=0; i<fres.numRen(); i++)
      {
         obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
         Canvas->LineTo(x, y);
      }
      for(int i=0;i<fres.numRen();i++)
         for(int j=0;j<fres.numCol();j++)
             FigGat[i][j]=fres.GETM(i,j);


    }




}
//-------------------------------------------------------------//
void __fastcall TForm1::Button3Click(TObject *Sender)
{
    Form1->Refresh();
   int tx= Edit3->Text.ToIntDef(0);
   
   int ty= Edit4->Text.ToIntDef(0);
   int ancho = Panel1->Width;


   Matrix fig,id,fres;
   if(band==true)
   {
      fig.Inicializa(4,3);
      id.Inicializa(3,3);
      fres.Inicializa(4,3);


      Matrix fig1, fig2, fig3;//
      Matrix fres1, fres2, fres3;//
      Matrix id1, id2, id3;  //


      for(int i=0;i<fig.numRen();i++)
         for(int j=0;j<fig.numCol();j++)
             fig.SETM(i,j,Fig[i][j]);


      for(int i=0;i<fig.numRen();i++)
         for(int j=0;j<fig.numCol();j++)
             fig1.SETM(i,j,Ojo1[i][j]);


      for(int i=0;i<fig.numRen();i++)
         for(int j=0;j<fig.numCol();j++)
             fig2.SETM(i,j,Ojo2[i][j]);


      for(int i=0;i<fig.numRen();i++)
         for(int j=0;j<fig.numCol();j++)
             fig3.SETM(i,j,Boca[i][j]);




      fres.escalacion(fig,id,tx,ty);    //
      fres1.escalacion(fig1,id, tx, tx);//
      fres2.escalacion(fig2,id2, tx, ty);//
      fres3.escalacion(fig3, id3, tx, ty);//




      int L = (Form1->ClientWidth-ancho)/2;
      int M = Form1->ClientHeight/2;
      UnidadII obj;
      obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      int x,y;  //
      int x1,y1;//
      int x2,y2;//
      int x3,y3;//




      obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
      Canvas->MoveTo(x,y);
      for(int i=0; i<fres.numRen(); i++)
      {
         obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
         Canvas->LineTo(x, y);
      }
      for(int i=0;i<fres.numRen();i++)
         for(int j=0;j<fres.numCol();j++)
             Fig[i][j]=fres.GETM(i,j);
             //----
     obj.mapeo(fres1.GETM(0,0), fres1.GETM(0,1), x1, y1, L, M);
      Canvas->MoveTo(x1,y1);
      for(int i=0; i<fres1.numRen(); i++)
      {
         obj.mapeo(fres1.GETM(i,0),fres1.GETM(i,1), x1, y1, L, M);
         Canvas->LineTo(x1, y1);
      }
      for(int i=0;i<fres1.numRen();i++)
         for(int j=0;j<fres1.numCol();j++)
             Ojo1[i][j]=fres1.GETM(i,j);
             //----


   }
   else if(band==false)
   {
      fig.Inicializa(34,3);
      id.Inicializa(3,3);
      fres.Inicializa(34,3);


      for(int i=0;i<fig.numRen();i++)
         for(int j=0;j<fig.numCol();j++)
             fig.SETM(i,j,FigGat[i][j]);


      fres.escalacion(fig,id,tx,ty);


      int L = (Form1->ClientWidth-ancho)/2;
      int M = Form1->ClientHeight/2;
      UnidadII obj;
      obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      int x,y;


      obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
      Canvas->MoveTo(x,y);
      for(int i=0; i<fres.numRen(); i++)
      {
         obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
         Canvas->LineTo(x, y);
      }
      for(int i=0;i<fres.numRen();i++)
         for(int j=0;j<fres.numCol();j++)
             FigGat[i][j]=fres.GETM(i,j);
   }




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


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


   Form1->Refresh();
   int sx= StrToFloat(Edit3->Text);
   int sy= StrToFloat(Edit4->Text);
   int tx=Edit5->Text.ToIntDef(1);
   int ty=Edit6->Text.ToIntDef(1);
   int ancho = Panel1->Width;


   Matrix fig,id,fres;
   if(band==true)
   {
      fig.Inicializa(4,3);
      id.Inicializa(3,3);
      fres.Inicializa(4,3);


      for(int i=0;i<fig.numRen();i++)
         for(int j=0;j<fig.numCol();j++)
             fig.SETM(i,j,Fig[i][j]);


      fres.escalacionpos(fig,id,sx,sy,tx,ty);


      int L = (Form1->ClientWidth - ancho) / 2;
      int M =  Form1->ClientHeight / 2;


      UnidadII obj;
      obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      int x, y;


      obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
      Canvas->MoveTo(x,y);
      for(int i=0; i<fres.numRen(); i++)
      {
         obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
         Canvas->LineTo(x, y);
      }
      for(int i=0;i<fres.numRen();i++)
         for(int j=0;j<fres.numCol();j++)
             Fig[i][j]=fres.GETM(i,j);
   }
      else if(band==false)
      {
         fig.Inicializa(34,3);
         id.Inicializa(3,3);
         fres.Inicializa(34,3);


      for(int i=0;i<fig.numRen();i++)
         for(int j=0;j<fig.numCol();j++)
             fig.SETM(i,j,FigGat[i][j]);


      fres.escalacionpos(fig,id,sx,sy,tx,ty);


      int L = (Form1->ClientWidth - ancho) / 2;
      int M =  Form1->ClientHeight / 2;


      UnidadII obj;
      obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
      int x, y;


      obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
      Canvas->MoveTo(x,y);
      for(int i=0; i<fres.numRen(); i++)
      {
         obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
         Canvas->LineTo(x, y);
      }
      for(int i=0;i<fres.numRen();i++)
         for(int j=0;j<fres.numCol();j++)
             FigGat[i][j]=fres.GETM(i,j);


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


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


   this->Width=945;
   this->Height=576;
}
//-------------------------------------------------------------//
void __fastcall TForm1::Button5Click(TObject *Sender)
{
   Form1->Refresh();
   int sx= StrToFloat(Edit7->Text);
   int sy= StrToFloat(Edit8->Text);
   int ang= StrToFloat(Edit9->Text);
   int ancho = Panel1->Width;


   Matrix fig,id,fres;
   if(band==true)
   {
     fig.Inicializa(4,3);
     id.Inicializa(3,3);
     fres.Inicializa(4,3);


     for(int i=0;i<fig.numRen();i++)
        for(int j=0;j<fig.numCol();j++)
            fig.SETM(i,j,Fig[i][j]);


     fres.rotacion(fig, id, sx, sy, ang );


     int L = (Form1->ClientWidth - ancho) / 2;
     int M =  Form1->ClientHeight / 2;
     UnidadII obj;
     obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
     obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
     int x, y;


     obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
     Canvas->MoveTo(x,y);
     for(int i=0; i<fres.numRen(); i++)
     {
        obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
        Canvas->LineTo(x, y);
     }
     for(int i=0;i<fres.numRen();i++)
        for(int j=0;j<fres.numCol();j++)
           Fig[i][j]=fres.GETM(i,j);
   }
   else if(band==false)
   {
     fig.Inicializa(34,3);
     id.Inicializa(3,3);
     fres.Inicializa(34,3);


     for(int i=0;i<fig.numRen();i++)
        for(int j=0;j<fig.numCol();j++)
            fig.SETM(i,j,FigGat[i][j]);


     fres.rotacion(fig, id, sx, sy, ang );


     int L = (Form1->ClientWidth - ancho) / 2;
     int M =  Form1->ClientHeight / 2;
     UnidadII obj;
     obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
     obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
     int x, y;


     obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
     Canvas->MoveTo(x,y);
     for(int i=0; i<fres.numRen(); i++)
     {
        obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
        Canvas->LineTo(x, y);
     }
     for(int i=0;i<fres.numRen();i++)
        for(int j=0;j<fres.numCol();j++)
           FigGat[i][j]=fres.GETM(i,j);
   }
}
//-------------------------------------------------------------//


void __fastcall TForm1::Button6Click(TObject *Sender)
{
   Form1->Refresh();
   int ancho = Panel1->Width;
   Matrix fig,id,fres;
   if(band==true)
   {
     fig.Inicializa(4,3);
     id.Inicializa(3,3);
     fres.Inicializa(4,3);
     int r=0;
     for(int i=0;i<fig.numRen();i++)
        for(int j=0;j<fig.numCol();j++)
            fig.SETM(i,j,Fig[i][j]);


     if(RadioButton1->Checked==true)
     {
        r=1;
        fres.Reflexion(fig,id, r);
     }
     if(RadioButton2->Checked==true )
     {
        r=2;
        fres.Reflexion(fig,id, r);
     }
     if(RadioButton3->Checked==true)
     {
        r=3;
        fres.Reflexion(fig,id, r);
     }
     if(RadioButton4->Checked==true)
     {
        r=4;
        fres.Reflexion(fig,id, r);
     }
     if(RadioButton5->Checked==true)
     {
        r=5;
        fres.Reflexion(fig,id, r);
     }


     int L = (Form1->ClientWidth - ancho) / 2;
     int M =  Form1->ClientHeight / 2;
     UnidadII obj;
     obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
     obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
     int x, y;


     obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
     Canvas->MoveTo(x,y);
     for(int i=0; i<fres.numRen(); i++)
     {
        obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
        Canvas->LineTo(x, y);
     }
     for(int i=0;i<fres.numRen();i++)
        for(int j=0;j<fres.numCol();j++)
            Fig[i][j]=fres.GETM(i,j);
   }
   else if(band==false)
   {
     fig.Inicializa(34,3);
     id.Inicializa(3,3);
     fres.Inicializa(34,3);
     int r=0;
     for(int i=0;i<fig.numRen();i++)
        for(int j=0;j<fig.numCol();j++)
            fig.SETM(i,j,FigGat[i][j]);


     if(RadioButton1->Checked==true)
     {
        r=1;
        fres.Reflexion(fig,id, r);
     }
     if(RadioButton2->Checked==true )
     {
        r=2;
        fres.Reflexion(fig,id, r);
     }
     if(RadioButton3->Checked==true)
     {
        r=3;
        fres.Reflexion(fig,id, r);
     }
     if(RadioButton4->Checked==true)
     {
        r=4;
        fres.Reflexion(fig,id, r);
     }
     if(RadioButton5->Checked==true)
     {
        r=5;
        fres.Reflexion(fig,id, r);
     }


     int L = (Form1->ClientWidth - ancho) / 2;
     int M =  Form1->ClientHeight / 2;
     UnidadII obj;
     obj.ventana((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
     obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,Form1->ClientWidth-ancho,Form1->ClientHeight/2);
     int x, y;


     obj.mapeo(fres.GETM(0,0), fres.GETM(0,1), x, y, L, M);
     Canvas->MoveTo(x,y);
     for(int i=0; i<fres.numRen(); i++)
     {
        obj.mapeo(fres.GETM(i,0),fres.GETM(i,1), x, y, L, M);
        Canvas->LineTo(x, y);
     }
     for(int i=0;i<fres.numRen();i++)
        for(int j=0;j<fres.numCol();j++)
            FigGat[i][j]=fres.GETM(i,j);


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


void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
     Edit4->Text=Edit3->Text;
}
//-------------------------------------------------------------//


void __fastcall TForm1::Button7Click(TObject *Sender)
{
   band=false;
//   Form1->Refresh();
   int ancho = Panel1->Width;
   int L = (Form1->ClientWidth-ancho)/2;
   int M = Form1->ClientHeight/2;
   FigGat[0][0]= 10; FigGat[0][1]= 20; FigGat[0][2]= 1;
   FigGat[1][0]= 50; FigGat[1][1]= 20; FigGat[1][2]= 1;
   FigGat[2][0]= 50; FigGat[2][1]= 40; FigGat[2][2]= 1;
   FigGat[3][0]= 30; FigGat[3][1]= 40; FigGat[3][2]= 1;
   FigGat[4][0]= 30; FigGat[4][1]= 50; FigGat[4][2]= 1;
   FigGat[5][0]= 40; FigGat[5][1]= 60; FigGat[5][2]= 1;
   FigGat[6][0]= 60; FigGat[6][1]= 60; FigGat[6][2]= 1;
   FigGat[7][0]= 60; FigGat[7][1]= 20; FigGat[7][2]= 1;
   FigGat[8][0]= 90; FigGat[8][1]= 20; FigGat[8][2]= 1;
   FigGat[9][0]= 90; FigGat[9][1]= 40; FigGat[9][2]= 1;
   FigGat[10][0]= 80; FigGat[10][1]= 40; FigGat[10][2]= 1;
   FigGat[11][0]= 80; FigGat[11][1]= 70; FigGat[11][2]= 1;
   FigGat[12][0]= 90; FigGat[12][1]= 60; FigGat[12][2]= 1;
   FigGat[13][0]= 110; FigGat[13][1]= 50; FigGat[13][2]= 1;
   FigGat[14][0]= 130; FigGat[14][1]= 50; FigGat[14][2]= 1;
   FigGat[15][0]= 150; FigGat[15][1]= 60; FigGat[15][2]= 1;
   FigGat[16][0]= 160; FigGat[16][1]= 70; FigGat[16][2]= 1;
   FigGat[17][0]= 160; FigGat[17][1]= 130; FigGat[17][2]= 1;
   FigGat[18][0]= 140; FigGat[18][1]= 110; FigGat[18][2]= 1;
   FigGat[19][0]= 100; FigGat[19][1]= 110; FigGat[19][2]= 1;
   FigGat[20][0]= 80; FigGat[20][1]= 130; FigGat[20][2]= 1;
   FigGat[21][0]= 80; FigGat[21][1]= 90; FigGat[21][2]= 1;
   FigGat[22][0]= 60; FigGat[22][1]= 110; FigGat[22][2]= 1;
   FigGat[23][0]= 40; FigGat[23][1]= 110; FigGat[23][2]= 1;
   FigGat[24][0]= 20; FigGat[24][1]= 90; FigGat[24][2]= 1;
   FigGat[25][0]= 20; FigGat[25][1]= 120; FigGat[25][2]= 1;
   FigGat[26][0]= 30; FigGat[26][1]= 120; FigGat[26][2]= 1;
   FigGat[27][0]= 50; FigGat[27][1]= 140; FigGat[27][2]= 1;
   FigGat[28][0]= 50; FigGat[28][1]= 150; FigGat[28][2]= 1;
   FigGat[29][0]= 30; FigGat[29][1]= 150; FigGat[29][2]= 1;
   FigGat[30][0]= 0; FigGat[30][1]= 120; FigGat[30][2]= 1;
   FigGat[31][0]= 0; FigGat[31][1]= 80; FigGat[31][2]= 1;
   FigGat[32][0]= 10; FigGat[32][1]= 20; FigGat[32][2]= 1;
   FigGat[33][0]= 10; FigGat[33][1]= 20; FigGat[33][2]= 1;


   Ojo1[0][0]=90;  Ojo1[0][1]=80;  Ojo1[0][2]=1;
   Ojo1[1][0]=110; Ojo1[1][1]=80;  Ojo1[1][2]=1;
   Ojo1[2][0]=110; Ojo1[2][1]=100; Ojo1[2][2]=1;
   Ojo1[3][0]=90;  Ojo1[3][1]=100; Ojo1[3][2]=1;
   Ojo1[4][0]=90;  Ojo1[4][1]=80;  Ojo1[4][2]=1;


   Ojo2[0][0]=130;  Ojo2[0][1]=80;  Ojo2[0][2]=1;
   Ojo2[1][0]=150;  Ojo2[1][1]=80;  Ojo2[1][2]=1;
   Ojo2[2][0]=150;  Ojo2[2][1]=100; Ojo2[2][2]=1;
   Ojo2[3][0]=130;  Ojo2[3][1]=100; Ojo2[3][2]=1;
   Ojo2[4][0]=130;  Ojo2[4][1]=80;  Ojo2[4][2]=1;


   Boca[0][0]=110;  Boca[0][1]=70;  Boca[0][2]=1;
   Boca[1][0]=130; Boca[1][1]=70;  Boca[1][2]=1;
   Boca[2][0]=120; Boca[2][1]=80; Boca[2][2]=1;
   Boca[3][0]=110;  Boca[3][1]=70; Boca[3][2]=1;


  //respaldar valores
  for(int i=0; i<34; i++)
    for(int j=0; j<3; j++)
       FigGatAux[i][j]=FigGat[i][j];


  UnidadII obj;
  obj.ventana((Form1->ClientWidth-ancho)/2,0,(Form1->ClientWidth-ancho),Form1->ClientHeight/2);
  obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,(Form1->ClientWidth-ancho),Form1->ClientHeight/2);


  int x, y;
  obj.mapeo(FigGat[0][0], FigGat[0][1], x, y, L, M);
  Canvas->MoveTo(x,y);






  for(int i=0; i<34; i++)
     {
      obj.mapeo(FigGat[i][0],FigGat[i][1], x, y, L, M);
      Canvas->LineTo(x,y);
     }


  int x1, y1;
  obj.mapeo(Ojo1[0][0], Ojo1[0][1], x1, y1, L, M);
  Canvas->MoveTo(x1,y1);
     for(int i=0; i<5; i++)
     {
      obj.mapeo(Ojo1[i][0],Ojo1[i][1], x1, y1, L, M);
      Canvas->LineTo(x1, y1);
     }


   int x2, y2;
  obj.mapeo(Ojo2[0][0], Ojo2[0][1], x2, y2, L, M);
  Canvas->MoveTo(x2,y2);
     for(int i=0; i<5; i++)
     {
      obj.mapeo(Ojo2[i][0],Ojo2[i][1], x2, y2, L, M);
      Canvas->LineTo(x2, y2);
     }


  int x3, y3;
  obj.mapeo(Boca[0][0], Boca[0][1], x3, y3, L, M);
  Canvas->MoveTo(x3,y3);
     for(int i=0; i<4; i++)
     {
      obj.mapeo(Boca[i][0],Boca[i][1], x3, y3, L, M);
      Canvas->LineTo(x3, y3);
     }


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


void __fastcall TForm1::UpDown2Click(TObject *Sender, TUDBtnType Button)
{
   Timer1->Enabled=false;
}
//-------------------------------------------------------------//


void __fastcall TForm1::UpDown1Click(TObject *Sender, TUDBtnType Button)
{
   Timer1->Enabled=true;        
}
//---------------------------------------------------------------------------


void __fastcall TForm1::Button8Click(TObject *Sender)
{
   band=false;
//   Form1->Refresh();
   int ancho = Panel1->Width;
   int L = (Form1->ClientWidth-ancho)/2;
   int M = Form1->ClientHeight/2;
   FigGat[0][0]= 60; FigGat[0][1]= 40; FigGat[0][2]= 1;
   FigGat[1][0]= 150; FigGat[1][1]= 40; FigGat[1][2]= 1;
   FigGat[2][0]= 160; FigGat[2][1]= 50; FigGat[2][2]= 1;
   FigGat[3][0]= 150; FigGat[3][1]= 40; FigGat[3][2]= 1;
   FigGat[4][0]= 120; FigGat[4][1]= 40; FigGat[4][2]= 1;
   FigGat[5][0]= 120; FigGat[5][1]= 60; FigGat[5][2]= 1;
   FigGat[6][0]= 90; FigGat[6][1]= 60; FigGat[6][2]= 1;
   FigGat[7][0]= 90; FigGat[7][1]= 40; FigGat[7][2]= 1;
   FigGat[8][0]= 90; FigGat[8][1]= 60; FigGat[8][2]= 1;
   FigGat[9][0]= 70; FigGat[9][1]= 60; FigGat[9][2]= 1;
   FigGat[10][0]= 50; FigGat[10][1]= 80; FigGat[10][2]= 1;
   FigGat[11][0]= 30; FigGat[11][1]= 90; FigGat[11][2]= 1;
   FigGat[12][0]= 20; FigGat[12][1]= 70; FigGat[12][2]= 1;
   FigGat[13][0]= 10; FigGat[13][1]= 70; FigGat[13][2]= 1;
   FigGat[14][0]= 0; FigGat[14][1]= 110; FigGat[14][2]= 1;
   FigGat[15][0]= 0; FigGat[15][1]= 120; FigGat[15][2]= 1;
   FigGat[16][0]= 10; FigGat[16][1]= 120; FigGat[16][2]= 1;
   FigGat[17][0]= 30; FigGat[17][1]= 100; FigGat[17][2]= 1;
   FigGat[18][0]= 50; FigGat[18][1]= 100; FigGat[18][2]= 1;
   FigGat[19][0]= 70; FigGat[19][1]= 110; FigGat[19][2]= 1;
   FigGat[20][0]= 80; FigGat[20][1]= 110; FigGat[20][2]= 1;
   FigGat[21][0]= 90; FigGat[21][1]= 110; FigGat[21][2]= 1;
   FigGat[22][0]= 80; FigGat[22][1]= 110; FigGat[22][2]= 1;
   FigGat[23][0]= 80; FigGat[23][1]= 140; FigGat[23][2]= 1;
   FigGat[24][0]= 10; FigGat[24][1]= 140; FigGat[24][2]= 1;
   FigGat[25][0]= 160; FigGat[25][1]= 140; FigGat[25][2]= 1;
   FigGat[26][0]= 90; FigGat[26][1]= 140; FigGat[26][2]= 1;
   FigGat[27][0]= 90; FigGat[27][1]= 110; FigGat[27][2]= 1;
   FigGat[28][0]= 120; FigGat[28][1]= 110; FigGat[28][2]= 1;
   FigGat[29][0]= 140; FigGat[29][1]= 90; FigGat[29][2]= 1;
   FigGat[30][0]= 160; FigGat[30][1]= 80; FigGat[30][2]= 1;
   FigGat[31][0]= 160; FigGat[31][1]= 70; FigGat[31][2]= 1;
   FigGat[32][0]= 140; FigGat[32][1]= 60; FigGat[32][2]= 1;
   FigGat[33][0]= 90; FigGat[33][1]= 60; FigGat[33][2]= 1;


   Ojo1[0][0]=90;  Ojo1[0][1]=80;  Ojo1[0][2]=1;
   Ojo1[1][0]=110; Ojo1[1][1]=80;  Ojo1[1][2]=1;
   Ojo1[2][0]=110; Ojo1[2][1]=100; Ojo1[2][2]=1;
   Ojo1[3][0]=90;  Ojo1[3][1]=100; Ojo1[3][2]=1;
   Ojo1[4][0]=90;  Ojo1[4][1]=80;  Ojo1[4][2]=1;


   Ojo2[0][0]=130;  Ojo2[0][1]=80;  Ojo2[0][2]=1;
   Ojo2[1][0]=150;  Ojo2[1][1]=80;  Ojo2[1][2]=1;
   Ojo2[2][0]=150;  Ojo2[2][1]=100; Ojo2[2][2]=1;
   Ojo2[3][0]=130;  Ojo2[3][1]=100; Ojo2[3][2]=1;
   Ojo2[4][0]=130;  Ojo2[4][1]=80;  Ojo2[4][2]=1;


   Boca[0][0]=110;  Boca[0][1]=70;  Boca[0][2]=1;
   Boca[1][0]=130; Boca[1][1]=70;  Boca[1][2]=1;
   Boca[2][0]=120; Boca[2][1]=80; Boca[2][2]=1;
   Boca[3][0]=110;  Boca[3][1]=70; Boca[3][2]=1;


  //respaldar valores
  for(int i=0; i<34; i++)
    for(int j=0; j<3; j++)
       FigGatAux[i][j]=FigGat[i][j];


  UnidadII obj;
  obj.ventana((Form1->ClientWidth-ancho)/2,0,(Form1->ClientWidth-ancho),Form1->ClientHeight/2);
  obj.puerto_vision((Form1->ClientWidth-ancho)/2,0,(Form1->ClientWidth-ancho),Form1->ClientHeight/2);


  int x, y;
  obj.mapeo(FigGat[0][0], FigGat[0][1], x, y, L, M);
  Canvas->MoveTo(x,y);






  for(int i=0; i<34; i++)
     {
      obj.mapeo(FigGat[i][0],FigGat[i][1], x, y, L, M);
      Canvas->LineTo(x,y);
     }


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


ESTE ES TODO EL POST COMENTEN Y HAGAN SUGERENCIAS Y NO OLVIDEN RECOMENDARLOS. GRACIAS!!!