Processamento de Imagem : Como obter uma funçao ?

[fender]

Ivan, se ainda tá usando aquele livro do Openheim?
Deseja se desfazer dele?


Humberto

[andre_luis]

...Tenho comprado bastante na Amazon sem problemas até o momento....

Ivan,

Voce saberia fazer uma estimativa do preço final aqui no Brasil se voce comprasse um livro na Amazon de U$ 49,99, com o dolar a 1,75 ?
Multiplicando, dá R$ 87,50, mas teria ainda os impostos + frete.
Digo isso, porque importando o livro abaixo pela Saraiva, :

Sai por R$ 149,60 que é a base usada na livraria onde importo.
Se tivesse uma noção do valor, poderia até decidir pela importação via livraria, caso não fosse tão grande a diferença.

+++

[Jorge_Francisco]

André,

Deixa eu ver se entendi: você quer obter a matriz que foi usada para ter a imagem final é isso?

Qualquer livro de processamento de imagens tem isso, eu fiz um programa que faz isso. Naquele exemplo que deu tem apenas duas rotações, no eixo z e no eixo y.

A questão é que teria que ter um padrão da imagem original e comparar com a gerada.

Lembrando que para rotacionar deve-se transladar a figura até o seu centro e depois sim, rotacionar nos eixos.

Jorge

[andre_luis]

Deixa eu ver se entendi: você quer obter a matriz que foi usada para ter a imagem final é isso?

Sim.

Qualquer livro de processamento de imagens tem isso...

Mas Jorge; naquele tutorial, e no livro indicado, o que é apresentado é como criar a matriz a partir da transformação desejada. Isso é operação matricial direta.
O que estamos falando, é de como obter a matriz de trasnformação, depois extrair daquela matriz numérica( ex.: 4x4 ), o que representa rotação/translação/escala entre 2 imagens diferentes.
Acredito que isso envolva um extenso cálculo literal que vai gerar várias equações, para então criar um algorítmo.

Aliás, no livro que possuo, como mencionei antes, a notação é extremantente complexa e pouco didática, e não tem uma vírgula sequer sobre algebra das transformações. Parece que o material é feito para o professor, e não para o aluno.


AT+

[Jorge_Francisco]

Eu tenho o livro de processamento digital(gonzales) em inglês, baixei no 4shared. Acho que ainda está por lá.

Obter as matrizes não será fácil, nem acho que precisará da matriz em si, a não ser que queira identificar se o objeto foi rotacionado ou se foi deslocado(mais perto ou mais longe),etc.

Acho complicado obter cada matriz...

[fender]

Eu tenho o livro de processamento digital(gonzales) em inglês, baixei no 4shared. Acho que ainda está por lá.

Obter as matrizes não será fácil, nem acho que precisará da matriz em si, a não ser que queira identificar se o objeto foi rotacionado ou se foi deslocado(mais perto ou mais longe),etc.

Acho complicado obter cada matriz...

Jorge ce consegue disponibilizar este livro pra gente?

André ce tem o pdf, ou o livro proprimeante dito? Caso queira se desfazer dele...

Abraços,
Humberto

[Jorge_Francisco]

http://www.4shared.com/file/164290957/5 ... a.html?s=1

Outra coisa, não existe comutatividade entre matrizes de rotação,translação,etc. Mais um motivo para ser complicado a ideia. A não ser que diga qual o objetivo... aí podemos pensar.

[Jorge_Francisco]

Procurei o programa aqui, mas não achei, teria que tirar de outro programa que fiz para uma empresa. Vou dar uma olhada, ainda lembro dos passos, e posso ir ajudando.

[andre_luis]

André ce tem o pdf, ou o livro proprimeante dito? Caso queira se desfazer dele...

Humberto,

Tenho ele impresso. Não sou muito fã de material em pdf, a menos que seja urgente. Sobre vender, não gosto de me desfazer do conhecimento (profundo...). Mesmo sendo pouco didático e tendo sido caro, tem muita informação alí.

...Obter as matrizes não será fácil, nem acho que precisará da matriz em si, a não ser que queira identificar se o objeto foi rotacionado ou se foi deslocado(mais perto ou mais longe),etc. Acho complicado obter cada matriz...

Jorge,

É isso mesmo. Extrair a partir de uma matriz numérica o valor de cada transformação, demanda uma álgebra com equações complicada, envolvendo inversa de funções trigonométricas, como abaixo :

Repare que a matriz acima está simplificada, e representa apenas as transformações de rotação. Se fosse trabalhar com translação e escala, terámos de aumentar a matriz de 3x3 para 4x4.

Certamente alguem já fez todo esse trabalho de extração das transformações em calculo literal ou por algorítmo, e era esse o Santo Graal que eu estava procurando.

+++

[Jorge_Francisco]

Para operações simples eu uso isto:

Operacoes3D.h

Código: Selecionar todos

enum TAxis
{
axisX, axisY, axisZ
};

enum TDimension
{
dimen2D,dimen3D
};

const
    sizeUndefined = 1,
    size2D        = 3,   // 'size' of 2D homogeneous vector or transform matrix
    size3D        = 4;   // 'size' of 3D homogeneous vector or transform matrix

const unsigned TIndex = 4;

struct TMatrix
{
   int size;
   float angleAxisX,angleAxisY,angleAxisZ;
   float matrix[TIndex][TIndex];

   TMatrix(){ size = sizeUndefined;angleAxisX =0;angleAxisY=0;angleAxisZ=0;}
};
//---------------------------------------------------------------------------
void MultiplyMatrices (TMatrix a,TMatrix b,TMatrix &c)
{
   int i,j,k;
   float temp;

   if(a.size == b.size)
   {
      for(i = 0;i < a.size;i++)
      {
         for(j = 0;j < a.size;j++)
         {
            temp = 0.0;

            for(k = 0;k < a.size;k++)
            {
            temp = temp + a.matrix[i][k] * b.matrix[k][j];
            }

         c.matrix[i][j] = temp;
         }
      }
   }

   else ShowMessage("Erro ao multiplicar Matrizes");
}

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

void Matrix2D( float m11,float m12,float m13,
               float m21,float m22,float m23,
               float m31,float m32,float m33,TMatrix &m)
{
      m.matrix[0][0] = m11; m.matrix[0][1] = m12; m.matrix[0][2] = m13;
      m.matrix[1][0] = m21; m.matrix[1][1] = m22; m.matrix[1][2] = m23;
      m.matrix[2][0] = m31; m.matrix[2][1] = m32; m.matrix[2][2] = m33;

      m.size = size2D;

}

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

void Matrix3D( float m11,float m12,float m13,float m14,
               float m21,float m22,float m23,float m24,
               float m31,float m32,float m33,float m34,
               float m41,float m42,float m43,float m44,TMatrix &m)
{     
      m.matrix[0][0] = m11; m.matrix[0][1] = m12;
      m.matrix[0][2] = m13; m.matrix[0][3] = m14;

      m.matrix[1][0] = m21; m.matrix[1][1] = m22;
      m.matrix[1][2] = m23; m.matrix[1][3] = m24;

      m.matrix[2][0] = m31; m.matrix[2][1] = m32;
      m.matrix[2][2] = m33; m.matrix[2][3] = m34;

      m.matrix[3][0] = m41; m.matrix[3][1] = m42;
      m.matrix[3][2] = m43; m.matrix[3][3] = m44;

      m.size = size3D;
}

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

void RotateMatrix(TDimension dimension,
                  TAxis xyz,
                  float angle,bool saveAngle,TMatrix &b)
{
   float cosx;
   float sinx;

   TMatrix a,c;
   
   c.size = b.size;

   switch(dimension)
   {
      case dimen2D:
         switch (xyz)
         {
            case axisX,
                 axisY:    ShowMessage("Rotação 2D inválida. Rotação apenas no EixoZ");

            break;

            case axisZ:    cosx = cos(angle-b.angleAxisZ);
                           sinx = sin(angle-b.angleAxisZ);

                           Matrix2D ( cosx, -sinx,     0,
                                      sinx,  cosx,     0,
                                      0,     0,     1,a);

                           b.angleAxisZ = angle;

            break;
         }
      break;

      case dimen3D:
         switch(xyz)
         {
            case axisX:    cosx = cos(angle-b.angleAxisX);
                           sinx = sin(angle-b.angleAxisX);

                           Matrix3D ( 1,     0,     0, 0,
                                      0,  cosx, -sinx, 0,
                                      0,  sinx,  cosx, 0,
                                      0,     0,     0, 1, a);

                           if(saveAngle)
                           b.angleAxisX = angle;

            break;

            case axisY:    cosx = cos(angle-b.angleAxisY);
                           sinx = sin(angle-b.angleAxisY);

                           Matrix3D ( cosx,     0,  sinx, 0,
                                         0,     1,     0, 0,
                                     -sinx,     0,  cosx, 0,
                                         0,     0,     0, 1,a);

                           if(saveAngle)
                           b.angleAxisY = angle;

            break;

            case axisZ:    cosx = cos(angle-b.angleAxisZ);
                           sinx = sin(angle-b.angleAxisZ);

                           Matrix3D ( cosx, -sinx,     0, 0,
                                      sinx,  cosx,     0, 0,
                                         0,     0,     1, 0,
                                         0,     0,     0, 1,a);

                           if(saveAngle)
                           b.angleAxisZ = angle;

            break;
         }
         break;
   }

   c.angleAxisX = b.angleAxisX;
   c.angleAxisY = b.angleAxisY;
   c.angleAxisZ = b.angleAxisZ;

   MultiplyMatrices(b,a,c);
   
   b = c;
}
//---------------------------------------------------------------------------

 

[Jorge_Francisco]

Um exemplo de uso, fiz nas coxas isso aí...

Código: Selecionar todos

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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Math.h"
#include "Operacoes3D.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "CSPIN"
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{
}

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

float aresta = 100;

unsigned OrigemXvirtual = 200;
unsigned OrigemYvirtual = 200;
unsigned OrigemZvirtual = 200;

unsigned posicaoX = 60;
unsigned posicaoY = 60;
unsigned posicaoZ = 60;

TMatrix Base,Topo;

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

void __fastcall TForm1::Criar_PontosClick(TObject *Sender)
{
   Matrix3D(
   0-aresta/2,0-aresta/2,0-aresta/2,1,//a
   aresta-aresta/2,0-aresta/2,0-aresta/2,1,//b
   aresta-aresta/2,aresta-aresta/2,0-aresta/2,1,//c
   0-aresta/2,aresta-aresta/2,0-aresta/2,1,//d
   Base
   );

   Matrix3D(
   0-aresta/2,0-aresta/2,aresta-aresta/2,1,//a
   aresta-aresta/2,0-aresta/2,aresta-aresta/2,1,//b
   aresta-aresta/2,aresta-aresta/2,aresta-aresta/2,1,//c
   0-aresta/2,aresta-aresta/2,aresta-aresta/2,1,//d
   Topo
   );
}

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

void PaintPolygon(TImage *Imagem,TMatrix z,TColor Cor)
{
   TPoint points[5];
   float PontoX,PontoY;

   for(int i=0; i < 4;i++)
   {
      PontoX = z.matrix[i][0]+50.0+aresta;
      PontoY = z.matrix[i][1]+50.0+aresta;
     
      points[i] = Point(PontoX,PontoY);

   }

   Imagem->Canvas->Brush->Color = Cor;
   points[4] = Point(z.matrix[0][0]+50+aresta,z.matrix[0][1]+50+aresta);

   Imagem->Canvas->Polygon(points,4);

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

/*********************************************************************

Primeiro método de rotacionar. Neste método a rotação se dá na posição
em que o objeto está e não de acordo com os seus pontos originais
conforme o segundo método.

**********************************************************************/


void __fastcall TForm1::CSpinEdit1Change(TObject *Sender)
{
   Form1->Image1->Picture = NULL;

   RotateMatrix(dimen3D,axisX,Form1->CSpinEdit1->Value*M_PI/180,true,Base);

   PaintPolygon(Form1->Image1,Base,clRed);

   RotateMatrix(dimen3D,axisX,Form1->CSpinEdit1->Value*M_PI/180,true,Topo);

   PaintPolygon(Form1->Image1,Topo,clBlue);

   for(int k=0;k<4;k++)
   {
   Form1->Image1->Canvas->MoveTo(Base.matrix[k][0]+50+aresta,Base.matrix[k][1]+50+aresta);
   Form1->Image1->Canvas->LineTo(Topo.matrix[k][0]+50+aresta,Topo.matrix[k][1]+50+aresta);
   }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::CSpinEdit2Change(TObject *Sender)
{
   Form1->Image1->Picture = NULL;

   RotateMatrix(dimen3D,axisY,Form1->CSpinEdit2->Value*M_PI/180,true,Base);

   PaintPolygon(Form1->Image1,Base,clRed);

   RotateMatrix(dimen3D,axisY,Form1->CSpinEdit2->Value*M_PI/180,true,Topo);

   PaintPolygon(Form1->Image1,Topo,clBlue);

   for(int k=0;k<4;k++)
   {
   Form1->Image1->Canvas->MoveTo(Base.matrix[k][0]+50+aresta,Base.matrix[k][1]+50+aresta);
   Form1->Image1->Canvas->LineTo(Topo.matrix[k][0]+50+aresta,Topo.matrix[k][1]+50+aresta);
   }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::CSpinEdit3Change(TObject *Sender)
{
   Form1->Image1->Picture = NULL;

   RotateMatrix(dimen3D,axisZ,Form1->CSpinEdit3->Value*M_PI/180,true,Base);

   PaintPolygon(Form1->Image1,Base,clRed);

   RotateMatrix(dimen3D,axisZ,Form1->CSpinEdit3->Value*M_PI/180,true,Topo);

   PaintPolygon(Form1->Image1,Topo,clBlue);

   for(int k=0;k<4;k++)
   {
   Form1->Image1->Canvas->MoveTo(Base.matrix[k][0]+50+aresta,Base.matrix[k][1]+50+aresta);
   Form1->Image1->Canvas->LineTo(Topo.matrix[k][0]+50+aresta,Topo.matrix[k][1]+50+aresta);
   }
}

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

/*********************************************************************

Segundo método de rotacionar. Neste método a rotação se dá de acordo
com os seus pontos originais.

**********************************************************************/

void teste()
{
   Form1->Criar_Pontos->Click();

   Form1->Image1->Picture = NULL;

   RotateMatrix(dimen3D,axisX,Form1->CSpinEdit4->Value*M_PI/180,false,Base);
   RotateMatrix(dimen3D,axisY,Form1->CSpinEdit5->Value*M_PI/180,false,Base);
   RotateMatrix(dimen3D,axisZ,Form1->CSpinEdit6->Value*M_PI/180,false,Base);

   PaintPolygon(Form1->Image1,Base,clRed);

   RotateMatrix(dimen3D,axisX,Form1->CSpinEdit4->Value*M_PI/180,false,Topo);
   RotateMatrix(dimen3D,axisY,Form1->CSpinEdit5->Value*M_PI/180,false,Topo);
   RotateMatrix(dimen3D,axisZ,Form1->CSpinEdit6->Value*M_PI/180,false,Topo);

   PaintPolygon(Form1->Image1,Topo,clBlue);

   for(int k=0;k<4;k++)
   {
   Form1->Image1->Canvas->MoveTo(Base.matrix[k][0]+50+aresta,Base.matrix[k][1]+50+aresta);
   Form1->Image1->Canvas->LineTo(Topo.matrix[k][0]+50+aresta,Topo.matrix[k][1]+50+aresta);
   }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::CSpinEdit4Change(TObject *Sender)
{
   teste();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::CSpinEdit5Change(TObject *Sender)
{
   teste();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::CSpinEdit6Change(TObject *Sender)
{
   teste();
}
//---------------------------------------------------------------------------



[Jorge_Francisco]

Eu faria da seguinte forma:

Escala:

-detectar as arestas da figura
-houve aumento ou diminuição, então encontro a escala, monto a matriz e divido pela matriz que quero obter.

Rotação:

-Encontro as diagonais
-meço o angulo entre arestas
-calculo o triangulo formado pelas arestas e pela diagonasl
-faço aproximação do angulo
-detecto uma das rotações
-divido a matriz anterior
-etc

e assim vai...

[andre_luis]

Jorge,

Obrigado pelo código. Vou dar uma olhada com calma e ver o que pode se extrair daí.
Minha única dúvida por enquanto é o significado do elemento a, no final de cada matriz de rotação.

at+

+++

[ivan]

Andre,

Segue o custo do livro Open CV na Amazon e livros não tem impostos.

http://rapidshare.com/files/326703680/O ... n.bmp.html

[ivan]

Humberto,

Infelizmente eu não me desfaço de livros, mesmo que não os esteja usando no momento.

Abs.