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!

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

16 comentarios:

  1. muchas gracias, no lo utilice asi como lo pegase pero me dio una buena idea de lo que debo de hacer.

    ResponderEliminar
  2. Buen programa, ¿cuales fueron tus fuentes de informacion y en que lenguaje lo hiciste?

    ResponderEliminar
  3. no tengo fuentes y el lenguaje es Builder C++

    ResponderEliminar
  4. no tienes el codigo en java, tengo q hacer un pain donde dibuje figuras en 2d y las pueda manipular con rotacion escalacion traslacion?

    ResponderEliminar
  5. oyes men no tienes el programa hecho para descargarlo?

    ResponderEliminar
  6. en que programa puede ser implementado?

    ResponderEliminar
  7. que onda bro no tendras el programa esta excelente bueno te dejo mi correo ber_na_be@hotmail.com

    ResponderEliminar
  8. Use el IDE Builder c++ y el codigo completo este en esta pagina, esta exactamente igual, solo hay que agregar cada uno de los commponentes(no se programan solo se agregan a la forma). Lamentablemente hace 2 años que hice este programa y ya no lo tengo.

    ResponderEliminar
  9. hey amigo tengo algunas dudas podrias ayudarme?? te lo agradeceria muchisimo

    ResponderEliminar
  10. Hola, disculpa nos podrías decir la forma en que compilaste tu proyecto ya que por mas que intentamos descifrar no podemos lograr que compile. Te agradecería tu ayuda. Somos alumnos del Tecnológico de Pachuca Hidalgo. Mi correo es este ieethczar@gmail.com

    ResponderEliminar
  11. Yo al igual que cesar gutierrez no consigo hacer que compile, soy estudiante en la facultad UNESC de Brasil, este es mi email alicia_uceda@hotmail.com

    ResponderEliminar
  12. Ok!! hablemos en $$$.. Cuanto por el programa funcionando?. Lo necesito en carácter extremadamente urgente!! Tengo una materia que pasar, tengo poco tiempo y otras materias mas que necesitan de mi atención. Mi oferta es a tiempo limitado, después ya no me serviría de nada!!!

    ResponderEliminar
  13. Quisiera saber por favor por que me sale error en UnidadII ME Sale indifinido el simbolo

    ResponderEliminar