Motivação para trabalhos intelectuais

.
Esta é a tirinha de Calvin & Haroldo que me inspirou durante o doutorado, em especial agora na reta final - quando entrei no, como Calvin diz, "right mood"... :-)

(clique na figura para ampliar)

Abraços!
Carlão

Só pra ser chato...

.
posição - país - ouro - prata - bronze

22 - Brasil - 3 - 4 - 8
...
27 - Cuba - 2 - 9 - 11
...
33 - Argentina - 2 - 0 - 3

:-)

Abraços!
Carlão

Doutorado: Geoprocessamento e Computação Inteligente: Possibilidades, vantagens e necessidades

.
[ ATUALIZAÇÃO 8.fevereiro.2009 ]
Texto e código-fonte disponíveis; correção de links;


RESUMO
As técnicas de análise de dados e de busca de soluções fornecidas pela Computação Inteligente tiveram, nos últimos tempos, um grande avanço em seu desenvolvimento. Essas técnicas têm sido utilizadas com eficácia e eficiência no tratamento de problemas complexos e/ou que possuam uma grande quantidade de dados a serem processados. A integração destas técnicas com as ferramentas computacionais de produção e análise de informações geográficas (Geoprocessamento) é, portanto, muito vantajosa, especialmente com relação à grande quantidade de dados geralmente envolvida nas questões de natureza espacial. Este trabalho apresenta dois exemplos de uso de técnicas de Computação Inteligente em procedimentos de produção e análise de informações geográficas: um Sistema de Raciocínio Nebuloso (baseado na Lógica Nebulosa) para a construção de um mapa de fertilidade de solos, e uma Rede Neural Artificial para a identificação de agrupamentos espaciais em dados sócio-econômicos. Os dois exemplos foram conduzidos utilizando-se um software especialmente construído para esta finalidade, denominado GAIA – Geoprocessamento Apoiado por Inteligência Artificial –, e que doravante está disponível como Software Livre para qualquer pesquisador interessado em utilizar estas ferramentas. O estudo conclui que o uso das técnicas provenientes da computação inteligente, em comparação com técnicas tradicionais de análise de dados, contribuiu para um aumento da qualidade dos resultados obtidos.


Texto disponível aqui


Software GAIA - Geoprocessamento Apoiado por Inteligência Artificial

Grupo de discussão:
http://groups.yahoo.com/group/gaia_geoprocessamento_ia

Licença:
GNU General Public License (GPL) version 3
Licença Pública Geral GNU - versão 3
Disponível em www.gnu.org/licenses/gpl.html
Tradução não oficial para português: www.fsfla.org/svnwiki/trad/GPLv3

- Executável (GNU/linux, i386, requer GTK)

- Dados dos exemplos

- Instruções para instalação

- Tutorial passo-a-passo para os exemplos apresentados na tese: inserido no texto da tese, disponível no link apresentado no início desta postagem

- Código-fonte

ATENÇÃO! está disponível acima apenas o código-fonte (arquivos cpp e glade, além de algumas imagens). Em breve disponibilizarei aqui o makefile, junto com instruções detalhadas para compilação junto com a TerraLib.


- live-cd (GAIA, TerraView, MYSQL, tutoriais + dados)

Arquivo ISO indisponível, por falta de local de hospedagem.
Leia-me !!

.

Netbeans 6.1 com C/C++ : Configurando um projeto para utilizar GTK - ATUALIZAÇÃO!! MUITO MAIS FÁCIL !!

.
Expliquei neste post como configurar o NetBeans 6.1 para compilar um programa usando a biblioteca GTK. Hoje, meio por acaso, descobri uma forma muitííííssimo mais simples!! De qualquer modo, o post original ainda merece ser consultado, pois contém algumas informações importantes e interessantes.

Vou direto ao ponto. Quem quiser ver telinhas, como já disse, consulte o post original.

Após criar o novo projeto:

1) abra a janela de propriedades do projeto;

2) No painel da esquerda, clique em "C compiler", debaixo de "Build";

3) No meio do topo da janela, no drop-down "configuration", escolha "all configurations" (a explicação deste item pode ser encontrada aqui);

4) No painel da direita, clique nos "três pontinhos" do item "additional options", localizado em "command line";

5) Na caixa "additional options", coloque:

`pkg-config --cflags gtk+-2.0`

6) clique em [OK];

7) No painel da esquerda, clique em "Linker", ainda dentro do grupo "Build";

8) No painel da direita, clique nos "três pontinhos" do item "additional options", localizado em "command line";

9) Na caixa "additional options", coloque:

`pkg-config --libs gtk+-2.0`

10) clique em [OK];

11) clique em [apply] e [OK] para fechar a janela de propriedades do projeto.

Prontinho!! Seu NetBeans está preparado para compilar usando GTK!

Abraços a todas e a todos!

Carlão

Netbeans 6.1 com C/C++ : Configurando um projeto para utilizar GTK

.
[ ATENÇÃO!! coloquei uma forma muito mais fácil neste post. Porém este post contém algumas imagens que podem ainda ser úteis ]

Siga esses passos para configurar o NetBeans 6.1 para compilar programas usando GTK. Estou admitindo que seu sistema já tem as bibliotecas necessárias instaladas (se não tiver, use o synaptic para instalar a biblioteca libgtk2.0-dev e suas dependências). Também estou admitindo que seu NetBeans tem o pacote para desenvolvimento C/C++:

1) Prepare um arquivo texto (chamei de "parametros.txt') com os parâmetros necessários (diretórios de includes e bibliotecas, e nomes de bibliotecas). Isso é feito, no terminal, utilizando o comando:

pkg-config --cflags --libs gtk+-2.0 > parametros.txt


2) Crie um novo projeto:

menu file | new project

3) Escolha C/C++ em categories, e C/C++ Application em Projects.

4) Preencha com os dados do projeto: nome e diretório onde será armazenado.

5) O projeto é criado, por padrão, para utilizar as ferramentas de debug. Para alternar entre essas formas de compilação (modos Debug ou Release), acesse:

build | set main project configuration

Escolha "release" se você não quiser informações de debug. Utilize essa opção apenas quando seu programa já estiver pronto! Para maiores detalhes sobre os modos de compilação, veja o post anterior.

6) Vamos agora definir os parâmetros de compilação específicos para uso da GTK, isto é, inserir no NetBeans os dados do arquivo "parametros.txt":

file | "nome_do_seu_projeto" properties , ou clique com o botão direito no nome do projeto, e escolha "properties".


Na janela que vai abrir, clique em "C compiler", debaixo de "build" (lado esquerdo da janela).


Neste momento, note a primeira linha da janela, tem um campo escrito "configuration: debug (active)". Isto significa que qualquer modificação só estará valendo para a compilação no modo Debug. Devemos trocar para "all configurations", ou seja, as configurações que faremos aqui valerão para qualquer tipo de compilação (Debug ou Release). ATENÇÃO! NAS TELAS ABAIXO, ESTE CAMPO DE CONFIGURAÇÃO APARECERÁ COMO "DEBUG", MAS O CORRETO É ESTAR COMO "ALL CONFIGURATIONS" !

Vamos preencher o item "include directories", dentro de "general" (clique no botão com três pontinhos a direita). Vai abrir uma janela para definição dos diretórios onde estão os includes (arquivos *.h).

7) Abra o arquivo "parametros.txt". Para cada item que iniciar com -I (traço mais letra "i" maiúscula), faça:

7.1) clique no botão "add";
7.2) copie o diretório (sem o "-i") no campo "file name" (dica: se você usar control-X, ao invés de control-C, os diretórios vão sumindo do arquivo "parametros.txt", e aí você vai controlando quais você já fez);
7.3) clique no botão "select";




Ao final, clique "OK".

8) Clique em "Apply".


9) Clique em "linker", ainda debaixo de "build". Depois, "libraries" embaixo de "libraries".


10) Clique em "add option". Na janela que vai abrir, escolha "other option".

11) Copie o resto do conteúdo do arquivo "parametros.txt" (itens que começam com "-l", traço mais letra éle minúscula) para esta janela, INCLUINDO os "-l".



12) OK ... Apply ... OK

13) Está pronto! Segue um pequeno programa GTK pra testar. Este programa gera uma janela vazia. Apesar da janela fechar quando clicamos no "x", o programa continua rodando, pois precisaríamos dotar o programa de uma resposta ao evento "fechar janela" (mas isso é papo pra depois...). Para fechar o programa, basta fechar o terminal que o NetBeans vai abrir para mostrar a janela.

#include stdio.h
#include stdlib.h
#include gtk/gtk.h
[ atenção!! colocar os sinais de menor e maior nas linhas acima!!!]

int main(int argc, char** argv)
{
GtkWidget *window;

gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Alou, Mundo!!");
gtk_widget_show (window);

gtk_main ();
return (EXIT_SUCCESS);
}

Pronto! Seu projeto está preparado para compilar programas que utilizem a biblioteca GTK, tanto no modo Debug quanto no modo Release.

Grande abraço!

Carlão

Netbeans 6.1 com C/C++ : A diferença entre o modo Release e o modo Debug

.
Você pode compilar seu projeto no NetBeans de duas formas diferentes: modo Debug e modo Release. A diferença entre eles é que no modo Debug seu projeto é compilado de uma forma que disponibiliza informações extras para permitir uma melhor avaliação do seu funcionamento e principalmente a caça de bugs (definição de pontos de parada na execução, verificação "on the fly" dos valores das variáveis, etc).

Vamos verificar na prática. Crie um novo projeto:

file | new project

categories: c/c++
projects: c/c++ application
[next]



project name: teste
[finish]



O NetBeans cria, por default, um diretório com o nome do seu projeto debaixo do diretório NetBeansProjects. Utilize seu navegador de arquivos e confira que dentro deste diretório "teste" só tem um único subdiretório, denominado "nbproject".

Vamos adicionar um arquivo com código-fonte em C:

file | new file

categories: c files
file types: main C file
[next]



Na próxima tela, apenas [finish]


Digite o seguinte programa:

#include stdio.h
#include stdlib.h
[nota: alguém sabe pq o blogger não deixa usar maior e menor??]

int main(int argc, char** argv)
{
int A, B, C;

A = 1;
B = 2;
C = 3;

printf(" %d - %d - %d ", A, B, C);

return (EXIT_SUCCESS);
}

A definição da forma de compilação é feita através do menu "build" :

build | set main project configuration | Debug ou Release


Escolha "release", e depois compile o projeto:

build | build main project

Utilize novamente o gerenciador de arquivos e olhe o interior do diretório "teste". Surgiram dois novos subdiretórios: "build" e "dist". No interior deste último, foi criado o diretório "release", contendo mais um subdiretório (gnu-linux-x86) e dentro dele o arquivo executável gerado por nossa compilação. O nome "release" não apareceu a toa, indica que compilamos nosso projeto no modo "release". Para finalizar esta etapa, anote o tamanho do arquivo executável que foi gerado (no meu caso, 6.3 KB).

Volte ao NetBeans, e escolha o modo de compilação "debug":

build | set main project configuration | Debug

E novamente compile o projeto:

build | build main project

Vamos olhar novamente o interior do diretório "dist". Foi criado agora o diretório "Debug", contendo o executável gerado pela compilação no modo "Debug" (novamente dentro de gnu-linux-x86). Vejamos o tamanho do arquivo executável: 7.3 KB.

Porque maior? Por que, como falei no início, no modo debug o executável é gerado com recursos extras que permitirão executar atividades de debug, tais como definição de pontos de parada, verificação do conteúdo das variáveis ENQUANTO O PROGRAMA ESTIVER RODANDO, etc.

Vamos ver isso funcionando ao vivo e a cores: Vamos definir um ponto de parada. Isso é feito clicando no número da linha onde se deseja que a execução pare. Vamos clicar na linha 8, onde atribuímos o valor 1 à variável A. Vai aparecer uma caixinha vermelha onde antes era o número da linha, e toda a linha ficará destacada em vermelho. Isso indica que a execução vai parar ANTES da execução desta linha.


Para executar o programa utilizando as informações extras de debug, utilize:

run | debug main project

A execução vai iniciar... e nada vai aparecer no terminal, porque o programa parou na linha que indicamos. Volte para a janela principal do NetBeans, e note o indicador estilo "supermáquina" ou "visor cylon" (depende da sua idade...) no canto inferior direito da janela. Isto indica que o programa está em execução, apenas está parado temporariamente. No código fonte, a linha onde o programa está parado fica verde.

Ainda olhando para o canto inferior direito da janela, note uma caixa com as variáveis A, B, C e seus valores, que devem ser os mais loucos possíveis. Isso acontece porque paramos o programa em um momento em que as variáveis foram criadas, mas nenhum valor foi (ainda) atribuído a elas, ou seja, elas estão com os valores aleatórios que toda variável em C recebe assim que é criada (na verdade, a variável não "recebe" nada; ela é associada a uma posição de memória que está com um valor qualquer, ou aleatório gerado quando o computador foi ligado, ou deixado por algum programa anterior).



Um dos recursos disponíveis para nós é a execução passo-a-passo do programa. Podemos mandar o NetBeans executar a próxima linha, e verificar as mudanças nos valores das variáveis (e desta forma, avaliar se o programa está fazendo as coisas corretamente!). Para isso, clique no botão com uma caixa azul e uma seta amarela apontando para baixo (o tooltip indica "step into"), ou vá no menu run | step into, ou simplesmente tecle F7.


A linha verde avançou para a próxima linha, isto é, ele executou o "A = 1". Isto também pode ser notado pela alteração do valor da variável A no box de variáveis.

Pode-se prosseguir assim passo a passo, ou pode-se mandar continuar a execução normalmente (teclando F5, clicando no botão com a seta "play" verde, ou menu run | continue). Note que podemos definir vários pontos de parada no programa.

Mais um teste para finalizar: mude o modo de compilação para "release":

build | set main project configurarion | release

Não precisamos recompilar, pois não mudamos o programa desde que geramos a versão release no início deste post. Vamos então tentar rodar esta versão release no modo debug:

run | debug main project

Necas! Ele ignorou nosso ponto de parada, pois o executável do tipo Release não está preparado para realizar debug.

Um último comentário, a janela de variáveis é bem interessante, pois mostra o conteúdo de membros de estruturas, valores de ponteiros, até mesmo valores de áreas alocadas dinamicamente (simulando um vetor a partir do ponteiro com o endereço inicial). Enfim, um recurso bem interessante pra quem não aguenta mais ficar colocando 'printf' no meio do programa.... (e geralmente esquecendo de tirar alguns deles no final!!)

Abraços a todas e a todos!
Carlão