DSD - Implementando:

Enfim (mesmo), vamos por a mão na massa ^^

Para Windows:

Primeiramente, baixem o pacote "DSD_Lite_tutorial". Descompactem ele em alguma pasta. O que temos que fazer agora é criar um novo projeto dentro do Workspace do ARToolkit. Isso é simples, basta abrir o workspace do ARToolkit com o visual 6.0, clicar em "Add new project to workspace", criar o projetinho do DSD e adicionar as pastas e arquivos que estão na pasta "src", localizados na pasta onde vocês descompactaram o pacote fornecido.
Provavelmente o workspace do ARToolkit vai estar configurado para gerar os binários na pasta "bin", dentro do ARToolkit, então coloquem por lá a pasta "Data", que também está dentro de "src", assim como as DLLs que, provavelmente, já estarão por lá, mas não custa copiá-las para lá também, por segurança.

Após isso, se tudo der certo, após dar o "build" vai estar por lá o executável "dsd.exe". Configurem a webcam, peguem a sua marca "Hiro" e executem. Caso esteja funcionando, vai aparecer uma janela preta. Se a webcam enxergar a marca, aparecerá uma imagem, que, se vocês não mudaram nada, será a de um quadrado amarelo com listas internas diagonais, verticais e na horizontal. A medida que vocês forem girando a marca, a imagem irá girar também (o dsd do código que disponibilizei está setado para fazer apenas a rotação de acordo com a marca).

Caso isso não funcione (aconteceu comigo de o visual surtar e me dar muitas mensagens obscuras e não deixar eu inserir o projeto dentro do workspace), existe uma alternativa nada elegante. Porém, para o bem da ciência, eu sugiro o seguinte:
  1. Troquem o código do exemplo "relationTest" pelo código que estou disponibilizando na página do projeto e coloquem também todo o conteudo restante da pasta "src" dentro da pasta "relation" (troquem de "dsd.cpp" para "relationTest.cpp";
  2. Adicionem na pasta "bin" a pasta "Data", junto no pacote onde forneci o código;
  3. Copiem as dlls e a imagem para dentro da pasta bin também.
  4. Compilem o projeto relativo ao relationTest e depois vejam o resultado na pasta "bin"
  5. Tenham a webcam configurada e uma marca "Hiro" impressa em mãos
  6. Façam a webcam enxergar a marca e, se tudo correu bem, vocês verão a imagem interagir com vocês =D

É feio, tosco e bárbaro. Mas funciona. Eu tentei algumas várias vezes criar um projeto dentro do projeto geral do ARToolkit, li tutoriais de como fazer isso, quebrei a cabeça horrores, mas a cada vez que tentava uma solução elegante eu tinha uma cascata de problemas para resolver, todos burocráticos e inúteis. Sugiro fortemente a vocês tentarem também fazer isso, pois provavelmente vocês conseguirão compilar de maneira mais formal e bonita o DSD. Mas, como já disse bastante aqui no tutorial, o foco é o DSD em si e não as maneiras de ele ser compilado, então vamos entender o código que vale mais a pena do que aprender as burocracias das IDEs =P

Para Linux:

No o pacote "DSD_Lite_tutorial_lin" já estão inclusos os códigos fontes listados abaixo. Na pasta "bin" serão gerados o executáveis "dsd_lite_rot", "dsd_lite_trans", "dsd_lite_trans_rot". Peguem a sua marca "Hiro" e executem o programa desejado. Se tudo der certo, a imagem "dsd.bmp', localizada na pasta "bin", irá obedecer os movimentos da marca "Hiro" detectada pela Webcam, sendo que o "dsd_lite_rot" acompanha somente os movimentos de rotação da marca, o "dsd_lite_trans" somente os de translação e o "dsd_lite_trans_rot" ambos os movimentos de rotação e translação ao mesmo tempo.
Com isso, podemos passar para a parte de entender o código.

O código:

Eu comentei o código com trechos importantes. Basta procurar a palavra "TUTORIAL". Boa parte do código é a tal "mágica" do ARToolkit que eu recomendo deixar intacta e mexer apenas nas partes menos perigosas. Mas fiquem a vontade se quiserem se aventurar e entender o ARToolkit, provavelmente será uma experiência que vai fazer vocês crescerem como pessoas ;)

A primeira parte é a seguinte:

/* TUTORIAL
  Esse DSD_LITE foi desenvolvido para ser mais simples (ter menos funcionalidades) do que o DSD antigo
  Este código é o que deve ser seguido durante o tutorial descrito em www.codeplex.com/MDVis/tutorial_dsd

  Esta primeira parte é o que foi retirado de exemplos do ARToolkit, que fazem toda a "mágica" acontecer
  Aconselha-se FORTEMENTE a quem está apenas trabalhando com o Tutorial a não se alterar o que está feito neste trecho
  Quem quiser se aventurar por estes códigos, sinta-se a vontade, porém tenha em mente que vai ser uma tarefa complicada =P

  Aos que estão fazendo o tutorial, pulem para a proxima seção TUTORIAL (ctrl+F)
*/

Apenas um comentário inicial resumindo o que eu disse até agora por aqui. É interessante para quem quer aprender mais sobre o ARToolkit ler os vários tutoriais disponíveis na internet (aqui eu vou disponibilizar uns links interessantes sobre isso).
No próximo trecho:

/* TUTORIAL:
   Abaixo estão listadas as 3 variáveis mais importantes do tutorial

   matrix: 
	é a variável onde vai ser criada a matrix de transformação de câmera

   objMatrix:
	onde será alocada a matrix de transformação da marca reconhecida pelo ARToolki
   
   dist_marca:
	distancia a qual as tablets estão distantes da marca. Ainda está sendo estudada uma maneira de tornar essa variável
	dinâmica e ainda sim manter uma real proporção entre as tablets e simular decentemente o aspecto de "janelas" do DSD.
	Por enquanto, isso deve ser definido no braço, através de uma calibração feita à mão.
	Quem achar uma maneira decente de se fazer isso, pode mandar um e-mail para mim: mrzacarias@gmail.com =D

   Ah, detalhe importante: no arquivo "draw.h" é onde está localizada a variável para carregar o bitmap a ser visualizado.
   Eu ainda não encontrei uma maneira de passar isso pra essa parte do código (pelo menos não enquanto faço este tutorial)
   Então, caso queiram mudar a imagem, é só procurar por lá.
   o padrão definido agora é "dsd.bmp"
 */


double		matrix[16];
double		objMatrix[16];
double		dist_mrz = 192;


/* A partir daqui, mais funções preferíveis de não serem alteradas =P */

Variáveis principais do programa, descritas mais especificamente no comentário. Para alterar o bmp que está sendo visualizado, basta ir na "draw.h" e mudar o parâmetro do objeto "Bitmap bitmap ("dsd.bmp");".
No próximo trecho:

/* TUTORIAL:
   
   Ok, agora chega a parte principal.
   As funções abaixo são para setar a matrix de transformação de camera a partir dos dados obtidos pelo DSD.

   Antes, um detalhe importante:
   A matrix que o ARToolki retorna está no formato de colunas, como se vê abaixo.
   
	ModelView Matriz obtida pelo artoolkit
	m[0]   m[4]   m[8]    m[12] 
	m[1]   m[5]   m[9]    m[13]  
	m[2]   m[6]   m[10]   m[14]  
	m[3]   m[7]   m[11]   m[15] 

   Sabendo-se disso podemos tratá-la como uma ModelView Matrix normal do OpenGl, apenas cuidando os índices
*/

//Função que inicializa a matrix com uma matriz identidade e com a distância padrão em Z
void initializeMatrix()
{
	int it = 0;
	
	while(it < 16)
	{
		if ((it == 0) || (it == 5) || (it == 10) || (it == 15))
			matrix[it] = 1;
		else 
			matrix[it] = 0;
		it++;
	}


	//deslocamento em Z, sempre igual para esse exemplo
	matrix[14] = dist_mrz;
}

//Função que permite a translação nos eixos X e Y
void applyTranslate()
{

	//deslocamento em X
	matrix[12]	= -objMatrix[12];

	//deslocamento em Y
	matrix[13]	= objMatrix[13];
}

//Função que permite rotação em torno do eixo Z
void applyRotate()
{

	//pegar valores 0,1,4,5, sendo 0 e 5 invertidos (espelhado)
	matrix[0]	= -objMatrix[0];
	matrix[1]	= objMatrix[1];
	matrix[4]	= objMatrix[4];
	matrix[5]	= -objMatrix[5];
}

//Função para imprimir a matriz no formato linha
void printMatrix()
{
	int i=0;
	
	while (i < 16)
	{
		if ((i == 3) || (i == 7) || (i == 11) || (i == 15))
			cout << matrix[i] << endl;
		else
			cout << matrix[i] << " ";
		i++;
	}
	cout << endl;
}


//Funcao SetMatrix
//Uma das mais importantes do DSD, seta a matriz de visualizacao a partir dos dados obtidos pela marca
void setMatrix(OBJECT_T obj){

	//inicialização dos fatores do OpenGL
	glViewport(0, 0, winWidth, winHeight);
	glClear(GL_COLOR_BUFFER_BIT );
	glMatrixMode(GL_MODELVIEW);
	

	//Função do ARToolkit que transfere informações da marca para a matriz "objMatrix"
	argConvGlpara(obj.trans, objMatrix);

	//A partir daqui, chamamos as funções criadas acima para fazer as funcionalidades do DSD


	//inicializa a matrix com a matriz identidade e o valor fixo de distância em Z, dist_mrz
	initializeMatrix();


	//torna possivel a translação em X e Y
	//applyTranslate();


	//torna possível a rotação em torno do eixo Z
	applyRotate();


	//imprime na tela os valores da matrix
	//printMatrix();


	//No caso acima, eu deixei as funções de imprimir e transladar o DSD comentadas
	//Esse DSD apenas rotaciona a imagem de acordo com a marca
	
	
	//Funções que adicionam a matriz de transformação ao resto do programa
	//fazendo assim o DSD tomar vida =D
	matchMatrix(matrixOld, matrix);
	glLoadMatrixd( matrixOld );	
}

//Com isso, termina-se o tutorial. Basta compilar isso. Quem quiser brincar com mais alternativas além de rotação e translação,
//fique à vontade para usar este código como base. Se quiser me mandar essas novas alternativas por e-mail, eu também
//ficarei muito feliz =D


E era isso. Eu creio que no código existem as informações necessárias para se entender o que está sendo feito, mas achei interessante reproduzir por aqui também o que disse por lá. Este exemplo gera um DSD que fazer apenas a imagem rotacionar de acordo com a marca. Se descomentarmos a linha "applyTranslate();", habilitamos também a translação. Essa base é altamente escalável em termos de funções novas.

Vocês tem toda a liberdade para usar este código para gerar outras transformações a partir das informações obtidas pela marca, brincando com as matrizes de transformação do OpenGL. Uma idéia interessante é fazer o Z da imagem corresponder ao da distância da marca para a webcam. Isso tem um efeito legal, nós usamos uma técnica semelhante para a tablet ter um efeito de "lente de aumento" sobre a imagem: Caso ela suba, a imagem aumenta. Isso está disponível no código completo do DSD já publicado faz algum tempo.

Outra alternativa interessante seria verificar a estrutura de dados gerada pela marca para isso, quem sabe não existem outros projetos interessantes que podemos fazer usando estas informações?

Bom, creio que de implementação é isso. Torno a dizer: os demais trechos de código do arquivo, não comentados aqui, são muito perigosos =S

=======================================================================
Anterior Próximo

Last edited Apr 1, 2009 at 8:35 PM by mrzacarias, version 10

Comments

No comments yet.