Tutoriais‎ > ‎

Computação Gráfica

Transformações no OpenGL

postado em 25 de mar. de 2016 17:02 por Prof. Rodrigo Costa

O propósito desta lição é compreender como as transformações geométricas são realizadas sobre os objetos no OpenGL através de funções para realizar translação, rotação e escalamento.

A aparência final da cena ou do objeto depende muito da ordem na qual estas transformações são aplicadas. No pipeline gráfico do opengl, antes dos pontos definidos através do comando glVertex serem exibidos na tela, eles passam por três estágios mostrado na figura a seguir


O primeiro passo desse processo é feito através de uma simples multiplicação de matriz. Assim, todos os pontos a serem desenhados passam são multiplicados por uma matriz especial, chamada MODELVIEW, conforme mostrado em:



Inicialmente ela consiste em uma matriz identidade, mas a cada tranformação esta matriz é alterada através da seguinte equação de atualização:


Desta forma, a cada aplicação de uma transformação, a matriz vais sendo alterada e consequentemente o resultado na tela vai também sendo alterado.

 

TransformaçãoComandoDescriçãoMatriz de Tranformação
TranslaçãoglTranslatef(Dx, Dy, Dz) move todas as coordenadas dos objetos ao longo dos eixos coordenados
Rotação glRotatef(Angulo, x, y, z) 

gira o objeto ao redor do vetor (x,y,z). 
O giro é de Angulo graus, no sentido anti-horário.

Como a rotação depende do vetor x,y,z, a seguir é descrito exemplos de matrizes para realizar rotações em torno dos eixos X, Y e Z.

EscalaglScalef(Sx, Sy, Sz) altera a escala do objeto ao logo dos eixos (X,Y,Z).

Na figura a seguir é mostrado o comando de rotação dos eixos coordenados:


Ordem da aplicação das transformações

Lembrando que a ordem das matrizes durante a formação da matriz composta implica em uma mudança na sequencia dos passos. Essa seção tem como o objetivo de demonstrar a influência da sequencia de aplicações de comandos na matriz de transformação.

Lembrando que a matriz padrão é uma identidade, ou seja, não altera os pontos, conforme mostrada a seguir:

Se aplicarmos uma transformação de translação com parâmetros Dx (Deslocamento em X), Dy (Deslocamento em Y) e Dz ( Deslocamento em Z), a matriz de modelview se altera conforme mostrado a seguir:


Se aplicarmos em seguida o comando de escalamento com fatores Sx, Sy e Sz, a matriz resultante é convertida em:

Lembrando que a sequencia de matrizes em uma transformação composta é o inverso da sequencia de aplicação. Assim, a matriz resultante representa a seguinte sequencia de transformação

  • Escalamento com fatores Sx,Sy e Sz
  • Translação com deslocamentos Dx, Dy e Dz.

Perceba, então, que a sequencia de comandos é o inverso da sequencia de transformações realizadas.

No código fonte a seguir percebe-se esse fenômeno:

 1 #include <windows.h>
 2  #ifdef __APPLE__
 3  #include <GLUT/glut.h>
 4  #else
 5  #include <GL/glut.h>
 6  #endif
 7  #include <stdlib.h>
 8  static void resize(int width, int height)
 9  {
10      glViewport(0, 0, width, height);
11  }
12  
13  void origem() /// desenha os eixos x e y
14  {
15      glColor3f(0,0,0);
16      glBegin(GL_LINES);
17      glVertex2f(-1,0);
18      glVertex2f(1,0);
19      glVertex2f(0,-1);
20      glVertex2f(0,1);
21      glEnd();
22  }
23  void forma() /// desenha um triangulo
24  {
25      glBegin(GL_POLYGON);
26          glVertex2f(0.2,0.2);
27          glVertex2f(0.2,0.4);
28          glVertex2f(0.4,0.4);
29      glEnd();
30  }
31  static void display(void) /// função chamada ao ocorrer um evento de atualização de tela
32 { 33 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 34 glLoadIdentity(); 35 origem(); 36 glColor3d(1,0,0); 37 forma(); /// desenho da forma sem transformação
38 glColor3d(0,1,0); 39 glTranslatef(-0.2, -0.4,0); 40 forma(); /// desenho da forma após a primeira modificação da matriz MODELVIEW 41 glColor3d(0,0,1); 42 glScalef(2,0.5,1); 43 forma(); /// desenho da forma após a segunda modificação da matriz MODELVIEW
44 glutSwapBuffers(); 45 } 46 static void key(unsigned char key, int x, int y) 47 { 48 49 glutPostRedisplay(); 50 } 51 int main(int argc, char *argv[]) 52 { 53 glutInit(&argc, argv); 54 glutInitWindowSize(640,480); 55 glutInitWindowPosition(10,10); 56 glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); 57 glutCreateWindow("Transformações"); 58 glutReshapeFunc(resize); 59 glutDisplayFunc(display); 60 glutKeyboardFunc(key); 61 glClearColor(1,1,1,1); 62 glutMainLoop(); 63 return EXIT_SUCCESS; 64 }

Perceba através da figura que ao aplicar os comandos na sequencia: 

  • glTranslatef(-0.2, -0.4,0);
  • glScalef(2,0.5,1);

resultou no triângulo de cor azul. Com essa sequencia de parametros, primeiramente o objeto sofreu um escalamento, fazendo com que o ponto (0.2, 0.2) se transformasse no ponto (0.4, 0.2). Em seguida, o objeto sofreu uma translação, fazendo com que o ponto (0.4, 0.2) se transformasse no ponto (0.2, -0.2). 

Esse exemplo, reforça ainda mais a importância da sequencia de comandos. Para aplicar uma sequencia desejada, deve inserir os comandos na sequencia do último até o primeiro, similar a posição das matrizes de transformação.

Aplicando sua própria matriz de transformação

O OpenGL permite você configurar manualmente a matriz de transformação através do comando 

void glLoadMatrixf( const GLfloat * A )

O comando recebe um vetor contendo cada uma das posições da matriz de transformação seguindo a sequencia mostrada na figura a seguir:

, em  que a é A matriz declarada ciomo GLfloat  A = {a0, a1, a2, ..., a15};

por exemplo, 

GLfloat  A = { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  0, 0, 0, 1 };
glLoadMatrixf( A); // carrega a matriz identidade e equivale ao comando glLoadIdentity();

GLfloat  B = { 
1, 0, 0, 0,
 0, 1, 0, 0,  
0, 0, 1, 0,  
Dx, Dy, Dz, 1 };

glLoadMatrixf( B); // carrega uma matriz de uma transformação de translação

Pilhas de Matrizes

O OpenGL permite com que as matrizes de trabalho sejam guardadas para posteriormente serem restauradas através de uma pilha.

O OpenGL permite a utilização de pilhas para 4 tipos de matrizes: cor, textura, transformações geométricas (MODELVIEW) e projeções. No momento, vamos nos ater a matriz padrão (MODELVIEW). Mas em aulas posteriores, trataremos das demais matrizes.

Esta funcionalidade é provida pelas funções glPushMatrix() glPopMatrix(). A primeira insere a matriz de transformação atual na pilha enquanto que a segunda retira a matriz do topo da pilha e torna esta última a matriz de transformação a atual.

Na figura a seguir é mostrado um trecho de código e a visualização das pilhas das matrizes


Existe uma forma avançada de se perceber o efeito do GLPUSHMATRIX e GLPOPMATRIX . Segundo especialistas, as transformações geométricas aplicads na matirz de modelview representam as açoes tomadas para reposicionamento da origem do sistema de coordenadas. 

Assim, ao realizar um GlPushMatrix, estamos definindo que todo desenho passa a ser representado relativamente em função de uma nova origem. O trecho de codigo a seguir mostra esse efeito.

  1 glLoadIdentity(); // faz com que O seja colocado em (0,0).
  2  origem(); // desenha a origem
  3      glPushMatrix(); /// faz com que o desenho seja feito em relação a (0,0)
  4          glRotatef(90,0,0,1);
  5          glTranslatef(0.2, 0.2, 0);
  6          // altera o (0,0) para o ponto (-0.2, 0.2). Pois ele sofreu uma translação seguida de rotação
  7          origem(); // desenha a nova origem O'
  8          .... // desenha os objetos em relação a essa nova origem
  9          glPushMatrix(); // guarda
 10             glTranslatef(0.4, 0.1, 0);
 11             glRotatef(angulo,0,0,1);
 12            // faz com que o eixo seja rotacionado por angulo graus e depois transladado em (0.4, 0.1).
 13            origem(); // desenha a nova origem
 14            ... // desenha em relação a 0''
 15          glPopMatrix(); // volta ao eixo de coordenada 0'
 16      glPopMatrix(); // volta ao eixo de coordenada 0


Exemplo 2 de código de tranformações 

#include<windows.h>
#include <GL/gl.h>
#include <GL/glut.h>
#include <math.h>
#include<stdio.h>
float lim = 10;

void eixos()
{
glLineWidth(1);
glBegin(GL_LINES);
glColor3f(0.5,0.5,0.5);
for (int x = - lim; x<lim;x++)
{
glVertex2f(x,lim);
glVertex2f(x,-lim);
glVertex2f(lim,x);
glVertex2f(-lim,x);
}
glEnd();
glLineWidth(4);
glBegin(GL_LINES);
glColor3f(0,0,0);

glVertex2f(0,lim);
glVertex2f(0,-lim);
glVertex2f(-lim,0);
glVertex2f(lim,0);
glEnd();
}
void triangulo_original()
{
glColor3f(1,0,0);
glBegin(GL_LINE_LOOP);
glVertex2f(3,3);
glVertex2f(6,7);
glVertex2f(3,10);
glEnd();
}

void triangulo()
{
glBegin(GL_LINE_LOOP);
glVertex2f(3,3);
glVertex2f(6,7);
glVertex2f(3,10);
glEnd();
}

void triangulo_final()
{
glColor3f(0,0,1);
glBegin(GL_LINE_LOOP);
glVertex2f(3,3);
glVertex2f(6,7);
glVertex2f(6,3);
glEnd();
}


void Desenha()
{
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-lim,lim,-lim,lim);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/*glViewport(400,300,400,300);
eixos();
triangulo_original();
triangulo_final();*/

glViewport(0,300,400,300);
eixos();
triangulo_original();
glColor3f(0,1,1);
glPushMatrix();
glTranslatef(-6,-7,0);
triangulo();
glPopMatrix();

glViewport(0,0,400,300);
eixos();
triangulo_original();
glColor3f(1,1,0);
glPushMatrix();
glRotatef(-atan(4.0/3.0)*180/M_PI,0,0,1);
glTranslatef(-6,-7,0);
triangulo();
glPopMatrix();

glViewport(400,0,400,300);
eixos();
triangulo_original();
glColor3f(0,1,0);
glPushMatrix();
glScalef(3.0/5.0,1,1);
glRotatef(-atan(4.0/3.0)*180/M_PI,0,0,1);
glTranslatef(-6,-7,0);
triangulo();
glPopMatrix();

glViewport(400,300,400,300);
eixos();
triangulo_original();
glColor3f(0,0,1);
glPushMatrix();
glTranslatef(6,3,1);
glScalef(3.0/5.0,1,1);
glRotatef(-atan(4.0/3.0)*180/M_PI,0,0,1);
glTranslatef(-6,-7,0);
triangulo();
glPopMatrix();
//triangulo_final();
glFlush();
}


int main (void)
{
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(800,600);
glutInitWindowPosition(283,84);
glutCreateWindow("exemplo");
glutDisplayFunc(Desenha);
glClearColor(1,1,1,1);
//printf("%f\n",atan(4.0/3.0)*180/M_PI);
glutMainLoop();
return 0;
}

Introdução ao OpenGL

postado em 16 de fev. de 2015 05:28 por Prof. Rodrigo Costa   [ 16 de fev. de 2015 05:33 atualizado‎(s)‎ ]

O OpenGL é uma ferramenta gráfica utilizada para geração de gráficos 2D e 3D, capaz de gerar gráficos de alta qualidade através de primitivas vetoriais e matriciais.
O OpenGL funciona como uma máquina de estados em que registra-se as ações decorrentes ao acontecimento de eventos como: 
–Mouse foi apertado
–Janela foi redimensionada
–Teclado foi pressionado
Esses eventos são escutados por um monitor do próprio OpenGL que inicia as ações programadas.
Cada evento dispara ações programadas pelo usuário ou seja, os eventos são tratados por rotinas callback da aplicação.

O OpenGL é composto por três partes:
  • —GLUT ( OpenGL Utility Toolkit)
    • —API portátil de acesso aos sistemas de janelas
    • —Encapsula e esconde as camadas proprietárias
    • —Não é parte oficial do OpenGL
  • GLU ( OpenGL Utility Library )
    • Parte do padrão OpenGL
    • NURBS, trianguladores , quádricas , etc.
  • AGL, GLX, WGL
    • Camadas entre o OpenGL os diversos sistemas de janelas

1. Configurando o Glut em Seu Computador

Nos links disponíveis a seguir é apresentado um guia passo a passo que ilustra o processo de configuração da biblioteca glut em Windows e Linux

  • https://sites.google.com/site/rodccosta/tutoriais/computacao-grafica/glut-linux
  • https://sites.google.com/site/rodccosta/tutoriais/computacao-grafica/glut-windows

Bem como utilizar o assistente disponível no CodeBlocks

  • https://sites.google.com/site/rodccosta/tutoriais/computacao-grafica/primeiroprojetoglutnocodeblocks

Estrutura de um Código C que utiliza a biblioteca Glut

#include <windows.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <stdio.h>
#include <stdlib.h>

CARREGAMENTO DE BIBLIOTECAS

OBS: O include <windows.h> é necessário apenas na plataforma windows

/* Declaração de Callbacks */
static void display(void)
{
glColor3d(1,0,0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutSwapBuffers();
}

Nesta fase são implementadas as ações decorrentes de eventos. Neste exempo é configurada a ação de limpar a tela após cada evento de solicitação de atualização de tela. 

int main(int argc, char *argv[])
{
// inicialização
glutInit(&argc, argv);
glutInitWindowSize(640,480);
glutInitWindowPosition(10,10);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("GLUT Shapes");

// registro de callbacks
glutDisplayFunc(display);

glClearColor(1,1,1,1);
glutMainLoop();

return EXIT_SUCCESS;
}

Função principal para inicialização do sistema e registro das calbacks para os eventos desejados. 

Neste exemplo só foi configurada a calback para o evento de atualização de tela.

Comentário sobre cada função de inicialização

glutInit ( int * argc , char ** argv )

Estabelece contato com sistema dejanelas. 
Pode-se passar alguns parâmetros aos sistema na chamada de função,

glutInitDisplayMode ( int modo )

Estabelece o tipo de recursos necessáriospara as janelas que serão criadas. Modo é um “ou” bit-a-bit de constantes:

•GLUT_RGB cores dos pixels serão expressos em RGB
•GLUT_DOUBLE bufferização dupla (ao invés de simples)
•GLUT_DEPTH buffer de profundidade (z-buffer)
•GLUT_ACCUM buffer de acumulação
•GLUT_ALPHA buffer de cores terá componente alfa

glutInitWindowPosition ( int x, int y)

Estabelece a posiçãoinicial do canto superior esquerdo da janela a ser criada

glutInitWindowSize ( int width , height )

Estabelece o tamanho (em pixels) da janela aser criada

int glutCreateWindow (char* nome)

Cria uma nova janela primária (top-level). O Nome é tipicamente usado para rotular a janela O número inteiro retornado é usado pelo GLUT para identificar a janela

glutMainDisplayLoop ()

Esta rotina na verdade é o “despachante” de eventos. Uma vez executada, a função principal é bloqueada pois estará tratando os eventos. Uma vez nela, só um evento pode fazer com que ela retorne

3. Registrando Callbacks

Os callbacks são rotinas que serão chamadas para tratar eventos. Para uma rotina callback ser efetivamente chamada ela precisa ser registrada através de funções que tem sintaxe similar a mostrada abaixo:

Exemplos:
  • GlutDisplayFunc ( callback ) 
  • GluMouseFunc ( callback ) 
Na tabela a seguir é apresentada a função de registro de calback e um template para cada função de calback e a descrição de seus parametros de entrada.
Função de Registro Modelo do Calback Descrição e Parametros
glutDisplayFunc(display)

void display ( void )
{
}

evento chamado quando um pixel na janela necessita ser atualizado.
glutReshapeFunc(reshape) void reshape ( int width , int height )
{
}
evento chamado quando a janela é redimensionada. Recebe como parametro os novos tamanho da janela (width, heigth)
glutKeyboardFunc(keyboard)  void keyboard(unsigned char key, int x, int y)
{
}
evento chamado ao pressionar uma tecla. Possui parametros key = tecla pressionada e (x,y) são as coordenadas do mouse.
glutMouseFunc(mouse) 
void mouse (int button, int state, int x, int y)
{

}
evento chamado ao pressionar um clicque do mouse.
Possui parametros button = botao pressionado e (x,y) são as coordenadas do mouse e State é o status do pressionamento (Clique ou liberação).
glutMotionFunc(motionPressed)

void motionPressed(int x, int y) {
}

chamada quando o usuário movimenta o mouseenquanto mantém um botão do mesmo pressionado.
(x,y) são as coordenadas do mouse 
glutPassiveMouseFunc(passiveMotion)  void passiveMotion(int x, int y) chamada quando o usuário movimenta o mouse enquanto mantém um botão do mesmo pressionado.
(x,y) são as coordenadas do mouse 
glutIdleFunc(idle)

void idle(void)
{

}

uma função de callback chamada quando nada nenhum evento foi pressionado. 

4. Desenhando primitivas

Dentro da função display ou qualquer momento do código você pode fazer solicitações de desenho.

  • glClearColor(R,G,B,A); escolhe a cor do fundo;
  • glClear( GL_COLOR_BUFFER_BIT ); limpa a tela
  • glColor3f(R,G,B) : especifica a cor de desenho atual;

Para desenhar algo, deve-se utilizar a estrutura a seguir :

glBegin(PRIMITIVA);
   glVertex2f(x,y);
  .....
glEnd();

Importante: por padrão o opengl só permite visualizar objetos que possuem -1 < x < 1 e -1 < y < 1.

As primitivas são configuráveis e você escolhe-as dentre os tipos a seguir:


Exemplo:

glBegin(GL_LINE_LOOP);
glVertex2f(0.114,-0.048);
glVertex2f(0.160,-0.122);
glVertex2f(0.176,-0.205);
glVertex2f(
0.092,-0.205);
glVertex2f(0.043, -0.130);

Resultado


Primeiro Projeto GLUT no Codeblocks

postado em 4 de out. de 2014 07:13 por Prof. Rodrigo Costa   [ 4 de out. de 2014 08:02 atualizado‎(s)‎ ]


A criação de um projeto de OpenGL no codeblocks é bem simples. Após abrir o programa crie um novo projeto conforme mostrado a seguir:

Na interface aberta, escolhe-s escolhe-se o tipo de projeto GLUT, conforme mostrado a seguir:

Na próxima tela é informado um aviso sobre o tipo de projeto, assim, simplesmente avance

Escolha um nome para seu projeto e escolha um diretório onde ficará armazenado o projeto.



Depois disto, é solicitada na primeira vez, a indicação do local onde está armazenado a bilbioteca. Se vc utilizou o instalador disponível neste site, você deve utilizar a pasta mingw do codeblocks.

Neste momento, falta pouco para concluir a configuração, vá em build options , conforme mostrado abaixo

Cique na aba linker e em seguida clique em add..
-

insira a lib do opengl e clique em ok
Volte a tela anterior e confirme suas configurações clicando em ok.
-+



Para finalizar a configuraçao, você deve inserir o seguinte include antes do código (na linha 14):
#include <windows.h> 

Pronto, depois disto, seu projeto está disponmível para usar.

Para simplificar o processo vc pode baixar um codigo pre configurado em:
https://sites.google.com/site/rodccosta/basico.rar

pkg-config

postado em 27 de jan. de 2014 09:46 por Prof. Rodrigo Costa

O pkg-config é uma ferramenta utilizada para a configurar qualquer projeto em sistemas Linux. Consegui juntar as algumas bibliotecas para rodar uma versão do pkg-config no Windows. No caso, deve-se colocar os arquivos necessários na pasta do compilador C e também configurar os parâmetros necessários ao PKG-CONFIG.
  1. Faz-se o download do arquivo clicando aqui. !!!!!
    Neste existe um executável pkg-config e também um arquivo opencv.pc (este arquivo irá guardar a configuração do seu sistema)
  2. Extrai-se o arquivo para dentro da pasta bin do mingw.
    CodeBlocks\MinGW\bin
  3. Depois disso, cria-se uma variável de ambiente PKG_CONFIG_PATH e faz seu valor ser igual a pasta bin do mingw. Exemplo
    PKG_CONFIG_PATH = C:\Program Files\CodeBlocks\MinGW\bin
  4. Insere-se no path do sistema a pasta C:\Program Files\CodeBlocks\MinGW\bin
  5. Depois disso, edita-se o arquivo opencv.pc, indicando o local correto do opencv e a versão correta das libs. No meu caso, as configurações são estas.
    # Package Information for pkg-config
    [email protected]@
    [email protected]_prefix@
    [email protected]@
    includedir=C:/Devel/OpenCV2.1/include/opencv
    Name: OpenCV
    Description: Intel(R) Open Source Computer Vision Library
    Version: @[email protected]
    Libs: -LC:/Devel/OpenCV2.1/lib -lml210 -lcvaux210 -lhighgui210 -lcv210  -lcxcore210
    Cflags: -I${includedir}
  6. Depois disso, o pkg-config já está configurado e basta criar um projeto no codeblocks, conforme mostrado na seção a seguir.

Criando o primeiro projeto

Em outro post, descrevo a configuração de um projeto, mas em linhas gerais, você precisa configurar as seguintes opções de projeto.
   
 Esta configuração é responsável por configurar as opções de compilação do opencv, indicando o local de onde encontram-se os .h do openc
 Esta configuração é responsável por definir a localização das bibliotecas, vem como definir quais delas são carregadas.

OpenCV 2.4.8 + MinGW + Codeblocks 12.10

postado em 27 de jan. de 2014 09:32 por Prof. Rodrigo Costa   [ 27 de jan. de 2014 09:44 atualizado‎(s)‎ ]

A partir da versão 2.4.6, o OpenCV decidiu abolir a versão pré-build para o Mingw, deixando na mão os desenvolvedores que preferem usar o codeblocks ao invés de utilizar o Visual Studio.

Eu particularmente, prefiro o CodeBlocks pelo fato de ser uma SDK bastante leve que ocupa apenas 46 MB de RAM e além disto é gratuita.
Fora a parte, criando um projeto com o CodeBlocks da forma que apresento no site, temos um projeto portável entre o Windows e Linux visto que também ambas as bibliotecas / SDK e ferramentas de apoio existem nos dois ambientes.

A versão 2.4.8 ocupa em disco 3.2 GB pois possui versões compiladas para o visual Studio 2010, 2011 e 2012 para ambas as plataformas (x86 e x64).

A seguir é apresentado um passo-a-passo reduzido para instalar o OpenCV 2.4.8 e utilizá-lo no Codeblocks 12.10.
  1. Baixar o opencv
    http://opencv.org/downloads.html
  2. Extrair para um diretório sem espaços por exemplo: C:\
    (Como não iria utilizar as versões x64 nem as versões do visual studio 2010 e 2011, resolvi apagá-los da pasta build e movi os diretórios da pasta build\x86\v12 para a pasta c:\opencv (resultando nos diretórios c:\opencv\bin, c:\opencv\lib)
  3. Baixar e extrair o pkg-config para a pasta bin do mingw (codeblocks\mingw\bin)
  4. Colocar a pasta bin do mingw no PATH e criar uma variável de ambiente PKG_CONFIG_PATH para o diretório BIN do Mingw
  5. Substituir o arquivo opencv.pc disponível no mingw\bin pelo disponibilizado no site.
  6. Inserir no path do sistema a pasta bin do opencv.
  7. Criar o projeto e pronto. 
Depois posto os screens.

Windows: Instalação do OpenCV 2.1 com Codeblocks 10.05

postado em 24 de fev. de 2012 20:26 por Prof. Rodrigo Costa   [ 1 de mai. de 2013 10:52 atualizado‎(s)‎ ]

O OpenCV é uma biblioteca utilizada para processamento de imagens. Ele possui a implementação de vários algoritmos de processamento de imagens, extração de características e até reconhecimento de padrões.

Este tutorial descreve a forma de instalação utilizando o compilador codeblocks, mas é plenamente possível adaptá-lo para outro compilador.

Inicialmente, tem-se que instalar o CodeBlocks, biblioteca e também alguns requisitos. É importante ressaltar que você deve instalar o codeblocks com o Mingw

Por exemplo:
 
A configuração do Linux é bastante simples, mas no Windows é meio entediante. Desenvolvi uma forma de configuração que torna tão fácil configurar o OpenCV no Windows.

Na época que foi feito esse tutorial, utilizei a versão 2.1, então com certeza quando você for instalar o tutorial em uma versão mais recente, talvez algumas modificações sejam necessárias.

Se o tutorial funcionou ou você gostou desta postagem, clique em curtir.


OpenCV 2.1

- Para funcionar, o opencv precisa da biblioteca VC Express 2008 SP1, disponível no site da microsoft.
- OpenCV 2.1, disponível aqui.
- E após tudo, vai e coloca o path do opencv\bin no path.

Para inserir algo no PATH ou criar uma nova variável de ambiente, deve-se primeiramente clicar em editar as variáveis de ambiente
https://sites.google.com/site/rodccosta/tutoriais/opencv-windows/varamb.png?attredirects=0&amp;d=1

 






Para editar uma variável de ambiente como o path, usa-se o botão editar, mas quando você quiser inserir uma nova variável, clique em novo


 

PKG-CONFIG

O pkg-config é uma ferramenta utilizada para a configurar qualquer projeto em sistemas Linux. Consegui juntar as algumas bibliotecas para rodar uma versão do pkg-config no Windows. No caso, deve-se colocar os arquivos necessários na pasta do compilador C e também configurar os parâmetros necessários ao PKG-CONFIG.
  1. Faz-se o download do arquivo em anexo à este post .
    Neste existe um executável pkg-config e também um arquivo opencv.pc (este arquivo irá guardar a configuração do seu sistema)
  2. Extrai-se o arquivo para dentro da pasta bin do mingw.
    CodeBlocks\MinGW\bin
  3. Depois disso, cria-se uma variável de ambiente PKG_CONFIG_PATH e faz seu valor ser igual a pasta bin do mingw. Exemplo
    PKG_CONFIG_PATH = C:\Program Files\CodeBlocks\MinGW\bin
  4. Insere-se no path do sistema a pasta C:\Program Files\CodeBlocks\MinGW\bin
  5. Depois disso, edita-se o arquivo opencv.pc, indicando o local correto do opencv e a versão correta das libs. No meu caso, as configurações são estas.
    # Package Information for pkg-config
    [email protected]@
    [email protected]_prefix@
    [email protected]@
    includedir=C:/Devel/OpenCV2.1/include/opencv
    Name: OpenCV
    Description: Intel(R) Open Source Computer Vision Library
    Version: @[email protected]
    Libs: -LC:/Devel/OpenCV2.1/lib -lml210 -lcvaux210 -lhighgui210 -lcv210  -lcxcore210
    Cflags: -I${includedir}
  6. Depois disso, o pkg-config já está configurado e basta criar um projeto no codeblocks, conforme mostrado na seção a seguir.

Criando o primeiro projeto

Em outro post, descrevo a configuração de um projeto, mas em linhas gerais, você precisa configurar as seguintes opções de projeto.
  
 Esta configuração é responsável por configurar as opções de compilação do opencv, indicando o local de onde encontram-se os .h do openc
 Esta configuração é responsável por definir a localização das bibliotecas, vem como definir quais delas são carregadas.

Windows: OPENGL - Instalando a biblioteca Glut no Windows

postado em 24 de fev. de 2012 20:07 por Prof. Rodrigo Costa   [ 1 de mai. de 2013 11:01 atualizado‎(s)‎ ]

Cansado de tentar instalar a glut e não conseguir?????
Vamos aqui fazer uma forma bem rápida, simples e indolor de se instalar esta biblioteca importantíssima para realizar a síntese de imagens usando o OPENGL, vamos lá? 
Se esse tutorial funcionou clique em curtir.


Passo 1: Instalar o codeblocks com mingw, disponível em http://prdownload.berlios.de/codeblocks/codeblocks-10.05mingw-setup.exe
Passo 2: baixem o arquivo que encontra-se em anexo a este post
Passo 3: extraiam o arquivo
Passo 4: executem o arquivo de lotes glut.bat em modo administrador

Linux: OpenGL - Instalação da Biblioteca Glut no Ubuntu

postado em 24 de fev. de 2012 20:05 por Prof. Rodrigo Costa   [ 1 de mai. de 2013 10:53 atualizado‎(s)‎ ]

Para os que desejem implementar aplicações no OpenGL no Linux é bem simples. Basta seguir esses passos:
sudo apt-get install codeblocks  freeglut3-dev build-essential libxxf86vm-dev
Caso você gostou deste tutorial e ele funcionou clique em curtir!!

Caso seu sistema operacional for 64 bits, você talvez necessite aplicar o seguinte comando para possibilitar que o codeblocks identifique as bibliotecas.

sudo ln -s /usr/lib/x86_64-linux-gnu/libglut.a /usr/lib/libglut.a
sudo ln -s /usr/lib/x86_64-linux-gnu/libglut.so /usr/lib/libglut.so
sudo ln -s /usr/lib/x86_64-linux-gnu/libglut.so.3 /usr/lib/libglut.so.3
sudo ln -s /usr/lib/x86_64-linux-gnu/libglut.so.3.9.0 /usr/lib/libglut.so.3.9.0

Depois disso, segue-se os passos básicos de inicialização, conforme mostrado a seguir:

  1. Clicaque no botão Novo > Projeto
  2. Depois disso, escolha o tipo de projeto GLUT PROJECT
  3. Escolha uma localização para ele avançar para a próxima tela
  4. Depois disso, indique a localização da biblioteca que encontra-se no /usr
 
 
 

1-8 of 8