Hoje, o Clube da Vida de Garanhuns criou seu blog para saudar os projteos reservados para 2009.

O clube da vida é formado por um grupo de pessoas de visão (foi meu pai quem teve a iniciatva), que se reúnem semanalmente, buscando qualidade de vida para Espírito, Alma e Corpo.

O blog está disponível no site http://clubedavidagaranhuns.blogspot.com

Feliz 2009 a todos!

Graças a Deus, o presidente assinou hoje o novo tratado de ortografia da língua portuguesa.

A partir de 1º de janeiro de 2009, entram em vigor as novas regras, sem abandonar as antigas, por enquanto…

Entre essas regras, está o fim do trema, aqueles dois pontos em cima do “u”, pra dizer que ele tem som de “u”. Que coisa, não?

Referência:

G1

Agora, de volta à monografia…

a galera do Firefox quer estabelecer o recorde mundial de downloads de software num espaço de 24 horas. eles estão lançando o download day, que vai acontecer quando lançarem a versão definitiva do Firefox 3. você pode clicar no botão aí em cima pra dar uma olhada no site da proposta. e abaixo, o texto da equipe do Firefox:

PS: trabalhos, trabalhos, trabalhos… essa semana eu vou ter quatro sextas-feiras 13…

PPS (Post-Post Scriptum): nas férias, vou tentar ajeitas esses trabalhos (os mais legais, pelo menos) pra postar aqui.

PPPS (Post-Post-Post Scriptum): São Paulo na velocidade 5 em cima do galo……. agora engatou!!!!
P…S: chega de PS….

vai uma dica de alguns livros, relacionada com o que estou tentando escrever pra cadeira de metodologia científica:

From Java to Ruby: Things Every Manager Should Know (Bruce Tate)
Rails for java Developers (Stuart Halloway e Justin Gehtland)
Ruby on Rails for PHP and Java Developers (Deepak Vohra)

outros títulos relacionados:

Ruby on Rails for Dummies
Agile Web Development for Rails (Dave Thomas e David Heinemeier Hansson)
Practical ReST on Rails 2 Projects (Ben Scofield)
The Rails Way (Obie Fernandez)

deu pra perceber que são em inglês, né? não vou colocar propaganda, porque ninguém tá me pagando e todo mundo sabe que tem na amazon (ou no emule).

OBS: as horas vagas estão ficando cada vez mais escassas (tem um campo de distorção temporal em algum lugar perto de mim). por isso, a mudança de título, em um momento em que eu deveria estar escrevendo um artigo.

a partir de hoje, temos uma nova seção: as notas de estudo de Ruby em português. são as notas de Satish Talim, traduzidas (por mim) para nosso idioma, o que torna mais fácil a vida de quem não entende inglês. Comecei hoje, então, ainda não temos muita coisa, mas, à medida que eu for traduzindo, a seção será atualizada. fiquem de olho (essa doeu), estou a todo vapor (ai!) traduzindo o tutorial, que tem mais de 120 páginas e é um ótimo guia de estudos para quem quer entrar no mundo de Ruby.

OBS: colaboradores, fiquem à vontade…

o programador indiano Satish Talim está oferecendo um curso de Ruby online (já vai na 5ª turma) DE GRAÇA!!! o curso é ministrado via moodle (um sistema usado para cursos à distância – depois escrevo sobre ele).

a duração é de 12 semanas e vai iniciar em 3 de maio. as inscrições ainda estão abertas (até 6 de maio) e qualquer um pode se inscrever. basta ir ao rubylearning.org, fazer o cadastro e enviar um e-mail para o Satish Talim, contendo seu nome e sobrenome cadastrados no site (o assunto deve ter o nome do curso incluso). cerca de um dia depois (ou menos), ele vai enviar uma chave para participar do curso. ao final, o participante recebe um certificado de participação.

antes de iniciar o curso, é recomendável que a gente leia (sim, eu me inscrevi) as notas de estudo disponíveis em rubylearning.com.

como nem tudo é perfeito, tem um pequeno problema, tanto no curso quanto no tutorial: são em inglês!!! o pessoal que souber inglês tem aí uma ótima fonte de aprendizado… pra quem não sabe, tem uma versão em espanhol aqui, traduzido por dois programadores mexicanos.

[EDIT] Já ia esquecendo… pra quem quer conhecer o projeto moodle e como funciona, essa é a página oficial do projeto…

PS: [off] que tal o tema novo do blog???

Devido ao início das aulas e de conseguir WoWar via Wine, fiz uma pequena pausa nos estudos de Ruby on Rails. Logo será retomado…

Enquanto isso, a gente tem trabalho de faculdade pra fazer, né??? O primeiro foi exatamente nessa cadeira: PDI. O assunto: equalização de histograma (legal, né?). Vamos ao trabalho:

Criar um programa em C/C++ que irá receber 2 parâmetros: o nome do arquivo de entrada e do arquivo de saída, respectivamente. O programa deverá ler o arquivo de entrada (arquivo de imagem no formato PGM ), realizar a equalização do histograma dos pixels e gravar a imagem equalizada no arquivo de saída.

Vamos ao programa:

um cabeçalho básico

#include <stdio.h>
#include <stdlib.h>
include <string.h>

mais a biblioteca para alocação dinâmica de memória

#include <malloc.h>

um vetorzão pra armazenar os pixels da imagem PGM, mais os protótipos das funções que utilizo no programa: uma pra processar PGM Ascii e outra pra processar PGM binário)

int **vValoresObtidos;
int arredonda(float valor);
int processaAscii(int cinzas, int largura, int altura, FILE *entrada, FILE *saida);
int processaBinario(int cinzas, int largura, int altura, FILE *entrada, FILE *saida);

A função main, que recebe os nomes dos arquivos pela linha de comando, escreve o cabeçalho do novo arquivo (Esse cabeçalho é em ascii, mesmo nos arquivos PGM binários). Os comentários no código explicam bem o que eu quiz fazer:

 int main(int argc, char** argv) {

    //declaração das variáveis
    FILE *entrada, *saida; //arquivos de entrada e saída
    int tonsDeCinza=0, largura=0, altura=0; //os nomes são auto-explicativos

    //variáveis auxiliares
    char param[5]; //pra ler do arquivo
    int p2p5=0; //pra verificar se o arquivo é ascii ou binário

    //se o número de parâmetros passados não for exatamente igual a 3, sai do programa
    if(argc != 3) return (EXIT_FAILURE)

    //verificação de que os nomes dos arquivos estão corretos
    printf("Arquivo de entrada é %s\n", argv[1]);
    printf("Arquivo de saída será %s\n", argv[2]);

    //verifica se os arquivos podem ser acessados:

    //arquivo de entrada, somente leitura
    if(!(entrada=fopen(argv[1], "r"))) {
        printf("arquivo %s não existe!!!\n", argv[1]);
        return(EXIT_FAILURE);
    }

    //arquivo de saída, leitura-escrita
    if(!(saida=fopen(argv[2], "w+"))){
        printf("Erro ao acessar o arquivo %s", argv[2]);
        return(EXIT_FAILURE);
    }

/* Uma observação sobre a passagem de argumentos de linha de comando em C:
 * C armazena em argc o número de parâmetros passados na linha de comando,
 * incluindo a chamada do próprio programa, por isso, se chamarmos o nosso programa
 * da forma correta, argc terá o valor 3 e argv, que armazena os parâmetros passados,
 * terá os valores: argv[0]: nome do programa, argv[1]: arquivo de entrada, argv[2]: arquivo de saída
 */

// criando o cabeçalho do novo arquivo:

// a condição de parada deste loop é chegar ao final do arquivo,
// isso é só uma garantia pra que um arquivo vazio ou mal formado não seja lido

    while(!feof(entrada)){
        fgets(param, 5, entrada); //lê até cinco caracteres do arquivo
        if(param[0]=='#') {
            //ignora os comentários
            while(getc(entrada)!='\n');
            continue;
        }

        if(param[0]=='P'){
            //verifica se o arquivo é ascii ou binário...
            //P2 diz que os dados estão em formato ascii, P5 diz que é binário
            p2p5=param[1]=='2'?2:5;
        }

        if(contaParam==1){
            //pega o primeiro parâmetro válido e atribui à largura
            largura=atoi(param);
        }else if (contaParam==2){
            //pega o segundo parâmetro válido e atribui à altura
            altura=atoi(param);
        }else if(contaParam==3){
            //pega o terceiro parâmetro válido e atribui aos tons de cinza
            tonsDeCinza=atoi(param);
        }

        //escreve os parâmetros no arquivo de saída

        //os arquivos PGM, mesmo que sejam no formato binário, têm seu cabeçalho em ASCII
        fprintf(saida, "%s", param);
        contaParam++;

        //depois de pegar os quatro primeiros parâmetros sai do laço
        if(contaParam >3)break;
    }

    //chama a função correta de interpretação

    if(p2p5==2){
        //como eu escrevi anteriormente, P2 é ASCII...
        processaAscii(tonsDeCinza, largura, altura, entrada, saida);
    }else if (p2p5==5){
        //e P5 é binário
        processaBinario(tonsDeCinza, largura, altura, entrada, saida);
    }else{
        //mensagem de erro. Enquanto estou escrevendo este post,
        //percebi que essa mensagem nunca será exibida,
        //por causa do operador ternário que eu utilizei na atribuição de p2p5
        printf("Erro de formato!!! O arquivo está mal definido!!!\n");
        return(EXIT_FAILURE);
    }

    //fecha os arquivos antes de sair
    fclose(entrada);
    fclose(saida);
    return (EXIT_SUCCESS);
}//fim do main

Agora, a função que faz o arredondamento de um número float. Ela retorna o valor inteiro mais próximo, somando 0.5 e cortando os decimais.

int arredonda(float valor){
    return (valor+0.5);
}

As funções processaAscii e processaBinário são praticamente iguais, a única diferença é na leitura e escrita no arquivo Vou utilizar a processaAscii como exemplo e citar o que é diferente na processaBinário.

int processaAscii(int cinzas, int largura, int altura, FILE *entrada, FILE *saida){
    
    //alocação de memória para os ponteiros de cada linha do arquivo
    vValoresObtidos=malloc(sizeof(int*)*largura);
    if(!vValoresObtidos) {printf("erro no malloc1"); exit(EXIT_FAILURE);}

    //declaração dos vetores
    int vCinzas[cinzas+1];
    float vProbabilidades[cinzas+1];
    float vAcumulado[cinzas+1];
    int vNormal[cinzas+1];

    //variáveis auxiliares
    int i, j;
    char parm[5]; //variável para ler caracteres do arquivo ascii. Não existe no processaBinário

    //alocação dos vetores de valores obtidos
    for(i=0;i<largura;i++){
        vValoresObtidos[i]=malloc(sizeof(int)*altura);
        if(!vValoresObtidos){
            printf("erro no malloc2");
            exit(EXIT_FAILURE);
        }
    }

    //inicialização dos vetores
    for(i=0;i<=cinzas;i++){
        vCinzas[i]=0;
        vProbabilidades[i]=0;
        vAcumulado[i]=0;
        vNormal[i]=0;
    }

    //lê os valores do arquivo e armazena na matriz que alocamos dinamicamente
    for(i=0;i<largura;i++){
        for(j=0;j<altura;j++){
            int valor;
            fgets(parm, 5, entrada);//não existe no processaBinario
            valor=atoi(parm);//fica assim: valor=fgetc(entrada);
            vValoresObtidos[i][j]=valor;
            vCinzas[valor]++;
        }
    }

    //agora os cálculos
    //cálculo das probabilidades e do acumulado
    vProbabilidades[0]=(float)(vCinzas[0])/(largura*altura);
    vAcumulado[0]=vProbabilidades[0];
    for(i=1;i<=cinzas;i++){
        vProbabilidades[i]=(float)(vCinzas[i])/(largura*altura);
        vAcumulado[i]=vAcumulado[i-1]+vProbabilidades[i];
    }

    //normalização
    for(i=0;i<=cinzas;i++){
        vNormal[i]=arredonda(vAcumulado[i]*cinzas);
    }

    //escrever novos valores
    for(i=0;i<largura;i++){
        for(j=0;j<altura;j++){
            char valor[5];
            sprintf(valor, "%d\n", vNormal[vValoresObtidos[i][j]]);
            fprintf(saida, valor);
            /* no código que processa binários, todo este corpo dos dois laços for
             * é substituído por
             * fputc(vNormal[vValoresObtidos[i][j]],saida);
             */
        }
    }

    //libera a memória e tremina a função
    for(i=0;i<largura;i++){
        free(vValoresObtidos[i]);
    }
    free(vValoresObtidos);
    return EXIT_SUCCESS;
} //fim da função processaAscii

Agora, é só compilar e rodar:

$ gcc equaliza.c -o equaliza $ ./equaliza <img_original> <nova_img>

Os resultados, utilizando a famosa imagem da lena (tive que converter pra png por causa do wordpress). A de cima é a original. Nas de baixo, a primeira fopi a equalizada pelo código e a segunda foi equalizada pelo GIMP:

Bom, o código não está perfeito. Estou trabalhando nele, portando pra Java e fazendo outro código para detecção de bordas aplicando o operador de Sobel. Valeu!!!

Estava passeando pelo Slashdot, quando vi uma idéia muito legal: O pessoal do Ubuntu tem um sistema de Brainstorming, ou seja, as pessoas dão as idéias e a própria comunidade avalia se a idéia é boa ou não. Daí, você já pode ter até uma idéia de como vai ser a próxima versão da nossa distribuição liveCD favorita. Qualquer um pode sugerir alguma idéia, é só criar uma conta no site.

Referências:

artigo no Slashdot
Ubuntu brainstorm

A notícia é de sábado, mas eu achei bem legal. Vi no softwarelivre.org que a Dell vai trazer notebooks (Da linha Vostro) com Ubuntu pré-instalado para o Brasil. O site não oferece mais detalhes, mas EU QUERO!!!!!!

Referência: http://www.softwarelivre.org/news/10861

Voltando a falar do Rails…..

Vou iniciar de novo um projeto de controle de fluxo de alunos no laboratório, usando como base os tutoriais presentes no Terminally Incoherent e no Akita on Rails. Então, vamos lá:

Depois de instalar o ruby, as gemas e o rails (veja aqui como fazer isso), vamos criar o projeto (Nota: é ainda mais fácil do que com o rails 1.2).

criando o projeto e o banco de dados

1. Não mudou nada em relação a criar o projeto. É só digitar (lembrando que o nome do projeto é relatorio):

rails relatorio

[editado]
para definir o mysql como banco de dados do projeto, pode-se colocar a opção

-d mysql

logo após o nome do projeto. No nosso caso, ficaria assim

rails relatorio -d mysql

[/editado]

2. Agora, sim, mudanças… Editar o arquivo config/database.yml, dentro da pasta do projeto (O Rails mudou o SGBD padrão para o SQLite3, então, vamos ter que modificar realmente o arquivo de definição de banco de dados para usá-lo com MySQL, que agora é da Sun). O meu arquivo ficou assim:

defaults: &defaults

  adapter: mysql

  encoding: utf8

  username: root

  password:

  socket: /var/run/mysqld/mysqld.sockdevelopment:

  database: sits_development

  <<: *defaults

test:

  database: sits_test

  <<: *defaults

production:

  database: sits_production

  <<: *defaults

Uma coisa que eu achei legal foi a parada do “defaults”. Dá pra definir os parâmetros que são iguais para os três bancos e utilizá-los nas outras definições do arquivo, só chamando um “atalho” para a definição dos defaults.

Depois de editado o arquivo de configuração, vamos criar os bancos de dados. Prepare-se, esta é uma etapa muito complicada, que envolve códigos SQL extremamente complexos. Muito cuidado, digite no terminal, dentro da pasta do projeto:

rake db:create:all

Ué, cadê o SQL extremamente complicado? Foi pro espaço (O final do parágrafo anterior foi só pra assustar… :p). Se você estiver duvidando, abra o mysql da forma que desejar e veja que os bancos de dados foram realmente criados.

criando o scaffold e as tabelas

Vamos agora, criar as tabelas para o banco de dados. Aqui, vou criar a tabela de alunos, já que é a mais simples do nosso projeto. Esqueça o SQL, os campos serão criados dentro do script de scaffold, da seguinte forma:

script/generate scaffold Aluno cpf:string nome:string curso:string

Agora, geramos o banco de dados utilizando o comando

rake db:migrate

Se você quiser olhar no mysql, verá que a tabela alunos foi realmente criada. Tudo isso sem uma única linha sequer de SQL. Legal, né?

Criando uma rota para a página principal

Para criar uma rota, é só editar o arquivo config/routes.rb. Por enquanto, vamos definir a página de cadastro de alunos (que já foi criada automaticamente pelo scaffold) como sendo a principal. Precisamos apenas incluir a linha

  map.root :controller => 'alunos'

logo abaixo de

ActionController::Routing::Routes.draw do |map|

Agora, depois de salvar o arquivo, deletamos a página public/index.html (Essa página é aquela que diz “Welcome Aboard”).

Pra ver o resultado, iniciamos o server com o comando

script/server

e verificar a aplicação no endereço localhost:3000 dentro do navegador.