Terramel

Nesta aula veremos a função glVertex3f que serve para construir vértices. Vamos usá-la para construir primeiramente um quadrado e mais para frente um cubo ;D Também brincaremos um pouco mais com as funções glColor3ub e a usaremos para fazer um degradê estiloso no quadrado ;D

Explicando a Função

A função glColor3f como já disse antes constrói um vértice. Se eu quero construir um quadrado com 10 pixels por exemplo, devo criar os quatro vértices com valores 5 usando quatro vezes a função glVertex3f. O primeiro vértice é o do lado superior direito, o segundo é o do lado superior esquerdo, o terceiro o lado inferior esquerdo e o quatro (obviamente) o lado inferior direito. Vamos dar uma olhada na imagem abaixo para termos uma idéia:

O comando deve ser chamado da seguinte forma: glVertex3f(x,y,z), onde x é a largura, y a altura e z a profundidade. Para criarmos o quadrado de 10 pixels vamos usar 4 vezes a função glVertex3f seguindo a ordem dos vértices, ou seja, o primeiro glVertex3f cuidará do primeiro vértice, o segundo cuidará do segundo e assim por diante. Portanto, para montarmos nosso quadrado de 10 pixels usaremos o comando quatro vezes da seguinte forma:

glVertex3f(5,5,0);
glVertex3f(-5,5,0);
glVertex3f(-5,-5,0);
glVertex3f(5,-5,0);

Por enquanto podemos deixar o z (profundidade) como 0. Isto fará todo o quadrado com o mesmo valor de profundidade, ou seja, 0. Se quiser podemos trazer ele para mais perto de nós aumentando o valor para algo como 10 por exemplo ou então deixá-lo mais afastado colocando um valor como -10. Podemos também deixar apenas um dos vértices mais pertos fazendo algo como:

glVertex3f(5,5,0);
glVertex3f(-5,5,0);
glVertex3f(-5,-5,0);
glVertex3f(5,-5,10);

Pondo a mão na massa

Agora que temos uma idéia melhor de como usar a função glVertex3f, vamos brincar um pouco usando o código do arquivo estrutura_basica.c que foi passada na primeira aula:

Vamos apagar a parte onde está o bule de chá e o cubo e vamos fazer nosso próprio quadrado. Se quiser fazer o download do arquivo basta clicar aqui. Se quiser, também pode copiar o código do arquivo que foi postado na primeira aula, colar em algum editor e salvar.

Vamos agora editar o arquivo:

Vá até a função DISPLAY do programa e apague tudo o que estiver entre glPushMatrix() e glPopMatrix() (ou seja, as funções glColor3ub e glColor4f, que servem para definir a cor, e as funções glutSolidCube e glutSolidTeapot.

Agora copie o seguinte código dentro de glPushMatrix():

glBegin(GL_QUADS);
	glColor3ub(255,255,255);
	glVertex3f(5,5,0);
	glVertex3f(-5,5,0);
	glVertex3f(-5,-5,0);
	glVertex3f(5,-5,0);
glEnd();

Salve o arquivo, compile e rode. Se você, assim como eu, for um feliz usuário de Linux basta usar o gcc para compilar:

gcc -o quadrado -Wall -lglut -lGL -lGLU estrutura_basica.c

e para rodar apenas digite:

./quadrado

Se fez tudo certo, então já está vendo uma janelinha com o quadrado que fizemos. Como fizemos o quadrado dentro do código do arquivo estrutura_basica.c, pode parecer que ele não está certinho, mas isso é porque ele está sendo visto de cima já que o programinha onde fizemos o quadrado inicia com os valores 0, 10, 20 na função gluLookAt, ou seja, o x está em 0, o y em 10 e o z em 20, por isso vemos ele no meio e um pouco do alto (já que y está em 10). Como o z (profundidade) está em 20, também estamos vendo ele um pouco de longe.

Agora vamos treinar um pouco mudando os valores do glVertex3f. Lembra mais acima que dei um exemplo mudando o valor do z de um dos vértices? Agora é a hora de fazer isso! Vamos ver como vai ficar ;D

Como pode ver, o vértice onde o z está com outro valor ficou afastado do resto do quadrado Uma boa idéia é brincar um pouco com os valores (x, y e z) do glVertex3f antes de prosseguirmos.

Cores e degradê

Agora que já fizemos o quadrado e brincamos um pouco com o glVertex3f, vamos mexer um pouco com as cores e aplicar um degradê phodão.

Lembra que antes de criarmos o quadrado usamos a função glColor3ub? Na primeira aula já vimos um pouco sobre esta função já que foi usada no código para dar cor ao cubo e ao bule de chá.

Relembrando, esta função é usada da seguinte forma: glColor3ub(r,g,b) onde r significa vermelho, g significa verde e b significa azul (Red, Green, Blue). Bem óbvio, né? Cada valor vai de 0 (mais escuro) até 255 (mais claro). Se por exemplo usarmos 0,0,0, estaremos pintando de preto e se usarmos 255,255,255, estaremos pintando (um doce para quem adivinhar) de branco (dãããã).

Quando criamos nosso quadrado usamos o glColor3ub com os valores 255,255,255. Isso fez o quadrado ficar branco. Se trocarmos por 0,0,0 o quadrado ficará preto (e não veremos na tela, já que a janela onde o quadrado foi criado é preta hehehehehe). Vamos testar trocar os valores para 20, 0 e 100 deixando a função da seguinte forma: glColor3ub(20,0,100);

Agora nosso quadrado que antes era chato e sem cor está diferente com uma linda e estilosa cor azul. EMOCIONANTE!!!!

Mas como tenho certeza de que muitos de meus leitores (e paraquedistas) no fundo são verdadeiros artistas (minha linda namorada, dona do blog GNU/Fabi, também é artista e já pintou vários quadros lindos e perfeitos), não ficaremos limitados a apenas uma cor, vamos agora aplicar um degradê phodão!

Nos exemplos anteriores pintamos o quadrado com apenas uma cor colocando o glColor3ub antes dos quatro glVertex3f. Para fazermos um degradê basta usarmos mais vezes o glColor3ub. Da mesma forma que cada comando glVertex3f é usado para fazer um vértice, podemos usar o glColor3ub antes de cada glVertex3f para pintar cada um dos vértices da cor que quisermos.

Vamos fazer agora o quadrado com o código do exemplo abaixo:

glColor3ub(20,0,100);
glVertex3f(5,5,0);
glVertex3f(-5,5,0);
glColor3ub(220,100,100);
glVertex3f(-5,-5,0);
glVertex3f(5,-5,0);

Como podem ver, usamos mais de uma vez o glColor3ub e com valores diferentes. O primeiro glColor3ub pinta com os valores 20, 0 e 100 (aquele lindo azul) o primeiro e o segundo vértice. O segundo glColor3ub pinta o terceiro e o quarto vértice com os valores 220, 100, 100 (Um rosa Hello Kitty para os emos que estiverem perdidos aqui ficarem felizes). Agora vamos compilar e executar o programa. Como podem ver, os vértices de baixo do quadrado (terceiro e quarto vértices) vão indo em degradê do rosa para o azul dos vértices de cima (primeiro e segundo vértices).

É aconselhável brincar um pouco com o glColor3ub para treinar um pouco e entender melhor o uso desta função.

Exercício

Usar o glVertex3f e o glColor3ub para criar um cubo em degradê verde e preto dos vértices da esquerda para os da direita. Uma dica antes de começar: Para criar o quadrado usamos o glVertex3f quatro vezes, portanto, para criar um cubo devemos usar 24 vezes o glVertex3f, já que devemos construir seis quadrados de mesmas proporções, apenas alterando os valores x, y e desta vez o z (profundidade) ;D

A resolução está abaixo! Boa sorte
Resolução do Exercício

glBegin(GL_QUADS);

	glColor3ub(0,200,0);
	glVertex3f(5,5,0);
	glColor3ub(0,0,200);
	glVertex3f(-5,5,0);
	glColor3ub(0,0,200);
	glVertex3f(-5,-5,0);
	glColor3ub(0,200,0);
	glVertex3f(5,-5,0);

	glColor3ub(0,200,0);
	glVertex3f(5,5,-10);
	glColor3ub(0,0,200);
	glVertex3f(-5,5,-10);
	glColor3ub(0,0,200);
	glVertex3f(-5,-5,-10);
	glColor3ub(0,200,0);
	glVertex3f(5,-5,-10);

	glColor3ub(0,200,0);
	glVertex3f(-5,5,-10);
	glColor3ub(0,0,200);
	glVertex3f(-5,5,0);
	glColor3ub(0,0,200);
	glVertex3f(-5,-5,0);
	glColor3ub(0,200,0);
	glVertex3f(-5,-5,-10);

	glColor3ub(0,200,0);
	glVertex3f(5,-5,-10);
	glColor3ub(0,0,200);
	glVertex3f(5,-5,0);
	glColor3ub(0,0,200);
	glVertex3f(5,5,0);
	glColor3ub(0,200,0);
	glVertex3f(5,5,-10);

	glColor3ub(0,200,0);
	glVertex3f(5,-5,0);
	glColor3ub(0,0,200);
	glVertex3f(-5,-5,0);
	glColor3ub(0,0,200);
	glVertex3f(-5,-5,-10);
	glColor3ub(0,200,0);
	glVertex3f(5,-5,-10);

	glColor3ub(0,200,0);
	glVertex3f(-5,5,0);
	glColor3ub(0,0,200);
	glVertex3f(5,5,0);
	glColor3ub(0,0,200);
	glVertex3f(5,5,-10);
	glColor3ub(0,200,0);
	glVertex3f(-5,5,-10);

glEnd();

Se conseguiu fazer o exercício certinho, então seu cubo com degradê de verde para azul deve ter ficado mais ou menos como o da figura
Espero que tenham entendido melhor esta aula. Finalmente estou me sentindo mais seguro com essa matéria e até começando a gostar mais. Este semestre o professor de Computação Gráfica mudou completamente a forma de passar a matéria e agora está muito melhor e mais simples de entender. Ontem mesmo já falei para ele que melhorou muito a forma de passar a aula, que estou entendendo mais e que essa aula que antes era a que eu menos gostava se tornou a aula que mais gosto de assistir na faculdade ;D

Technorati Tags: Computação Gráfica, OpenGL, glVertex3f, quadrado, cubo, glColor3ub, GL_QUADS, glBegin, glEnd, Vértices, vértice, função, comando, funções, comandos, C, gcc, compila, compilar, imagem, 3D, gráfico, pixel, pixels, largura, altura profundidade

Powered by ScribeFire.

Tags: Aulas by Terramel
6 Comments »

Miguel de Icaza, conhecido por projetos como Gnome, Monopólio, Moonlight, já tem um clone seguidor aqui no Brasil: César Brod. César Brod já é bem conhecido pela comunidade brasileira de Software Livre pelos trabalhos e atuações que já fez pelo Software Livre. Além de ter contribuido com vários artigos sobre GNU/Linux e Software Livre, chegou participar de um debate contra a Microsoft.

Sua empresa, Brod Tecnologia, atualmente presta serviços para a Microsoft. Não teria nada contra parcerias e acordos, nem mesmo os que são feitos com empresas como a M$. O único problema é que esses acordos parecem mudar radicalmente as opiniões das partes envolvidas com a M$. Muito ($$$$)estranho($$$$)….

Como muitos já sabem, ocorreu nesta terça-feira a reunião final da ABNT onde foi discutido qual seria o voto do Brasil em relações aos padrões de documentos ODF e OOXML. Não vou falar muito sobre isso já que muitas informações e opiniões foram dadas em diversos blogs e sites. No blog de Avi Alkalay da IBM Brasil, você encontrará informações e impressões sobre a reunião que ocorreu terça na ABNT.

Várias empresas estiveram presentes na reunião. O SIM era mantido pela Micro$oft, Unesp (que vergonha, uma faculdade pública! Shame on you, Unesp!), SUCESU-SP, Associação de Parceiros da Microsoft, e algumas empresas regionais ou de alcance menor (resumindo, todos que tem o rabo preso com a M$). O NÃO era mantido por empresas e instituições governamentais como MCT, ITI, MP, Banco do Brasil, Caixa Econonômica, Correios, Serpro, Celepar etc, mais organizações como BrOffice.org, Rede Livre, ODF Alliance e mais empresas como Sun, Red Hat, 4Linux, IBM, Metrô de São Paulo, Google e outras.

Uma coisa que não apenas eu, mas muita gente achou estranho foi o fato de César Brod ter votado SIM com comentários. Muitos pessoas tentaram entender melhor seu posicionamento consultando dois de seus artigos que foram publicados no Dicas-l. No primeiro artigo, publicado no mês passado, ele fala sobre padrões fazendo comparações entre a briga que teve há muitos anos entre VHS e Betamax. No segundo artigo, que foi publicado hoje, ele fala porque se posicionou a favor do OOXML.

Na humilde opinião deste quem vos escreve, o nosso coleguinha César Brod já estava “preparando o terreno” em seu primeiro artigo. Se me permitem, vou dar umas comentadas em algumas coisas que ele escreveu nestes artigos:

“Eu fico preocupado é com o futuro… Eu sei que não vou resistir e vou acabar comprando um VHS ou um Betamax, torcendo para que a maioria tome a mesma decisão que eu. Mas imagina se, daqui há pouco, um louco qualquer inventa de criar uma coisa que sirva como armazenamento e reprodução de áudio e vídeo ao mesmo tempo? Será que este maluco vai se preocupar com a minha coleção de fitas de vídeo, áudio, meus LPs, e criar algo que, além de tocar a “coisa nova” ainda reproduza as “coisas velhas”? Du-vi-de-o-dó, como diz minha mãe, a Dona Ione! Prova disto são os gravadores e toca-fitas! Algum deles toca aquelas fitas de rolo que usávamos há poucos anos?”

Claro, claro meu querido! Então da mesma forma os microondas não deveriam ser criados… Imagine só! O que as farão as pobres donas de casa com as tantas panelas que tem na cozinha? Metal no microondas acaba dando merda! OMG!!!! As panelas estão condenadas!!!! Ops! Mas nós estamos em 2007 e já existem microondas há tanto tempo. Estranho, tem também um fogão e várias panelas na minha cozinha. Outro dia até fiz o meu deliciosíssimo GNU/Macarrão para minha namorada

“Ainda aposto que, se no futuro, alguém se preocupar em criar padrões que respeitem a compatibilidade com tudo o que foi criado antes, este alguém vai ser taxado de louco ou coisa parecida! Mas, se apenas em hipótese, este “tudo o que foi criado antes” seja justamente informações, documentos que fazem parte de todo um conhecimento empresarial? Milhões de milhões de textos e planilhas de cálculo!”

A M$ nunca se preocupou em respeitar a compatibilidade com outros softwares como o OpenOffice. Você prefere ficar preso por documentos antigos do que aceitar uma mudança para um padrão que seja realmente aberto e transparente? As empresas não perderão suas informações simplesmente por uma mudança na padronização. Um novo formato pode ser adotado, mas isso não significa que os formatos antigos junto com os softwares capazes de lê-los serão apagados da face da terra. Respondo isso com uma analogia parecida com a que você usou em seus exemplos: Não é porque existe DVD hoje que não assisto algumas fitas VHS, da mesma forma que não parei de ouvir LPs simplesmente porque existe CDs. Apenas tenho mais opções

“Que bobagem pensar nisto, né? É tão fácil jogar coisas fora! Mas sei lá, eu acho que vou ter mais de 40 anos e ainda vou querer ouvir meus velhos LPs…”

Como já expliquei antes, não precisei jogar minhas fitas k7 fora, da mesma forma que não precisei jogar os meus LPs. Tenho ainda meus LPs do Queen, Alice Cooper, Extreme, Judas Priest, Faith No More, Alan Parson’s Project e muitos outros que ouço sempre que dá vontade

“Existe cerca de 40 bilhões de documentos armazenados em formatos binários da Microsoft. Estes documentos, abertos com novas versões do Office e salvos em formato OpenXML passam a ser acessíveis por uma série de aplicativos que agora usufruem de um legado de textos e planilhas, que podem servir como base para sistemas de busca de conhecimento coletivo, business intelligence, dentre muitos outros, que podem até ser desenvolvidos como software livre e de código aberto.”

Triste isso, não? Parece que cada vez que algum outro software chega mais perto da compatibilidade com estes formatos, a M$ lança uma nova versão e faz alguma mudança nesses documentos. O pior é que geralmente o usuário final, alheio a tudo isto, acaba pensando que a culpa é do OpenOffice, BrOffice, que o problema é com o Linux e muitas vezes esta história acaba em: “Vamo ligá pru técnico que ele bota Windows, Word e Excel rapidim só por 50 pilas!”. A M$ gosta disso. Ela nunca mostrou interesse algum em abrir seus documentos. Foi só aparecer o ODF que a M$ correu atrás com o tal do OOXML, um padrão (se é que podemos chamar de padrão) totalmente mal implementado e ainda por cima com partes binárias.

Acho que não preciso mais comentar sobre isso. Muitas pessoas da comunidade tem conhecimento e muitos textos por ai já falam sobre todo este assunto de padrões de documentos. Acho que não é novidade nenhuma dizer que fiquei decepcionado com o voto de César Brod, assim como sei que muitos outros também ficaram. É triste isso… Já não bastam Novell, Xandros, Linspire, Miguel de Icaza? Talvez essas pessoas apenas estejam usando o Software Livre e a comunidade para fazer dinheiro, coisa que acho extremamente desprezível. Mas quem sou eu para criticar as preferências empresariais, ideológicas, políticas e tecnológicas das pessoas… O que posso fazer se alguns acham as notinhas dos tios Bill & Ballmer (poderia ser dupla sertaneja né?) mais verdes?

Gostaria de não ter que escrever este desabafo, mas depois dessa, sempre que ler ou ouvir o nome César Brod lembrarei do título deste post: “César Brod, o Miguel de Icaza brasileiro!”

Technorati Tags: Miguel de Icaza, César Brod, Brod, Icaza, brasileiro, ODF, OOXML, ABNT, voto, sim, não, comentários, ballmer, bill gates, bill, steve ballmer, microsoft, M$, micro$oft, ms, software livre, documentos, planilhas, textos, word, openoffice, broffice, excel, office, acordo, parceria, empresas

Powered by ScribeFire.

Tags: Tecnologia by Terramel
28 Comments »

Esta é a segunda aula de banco de dados que posto. Praticamente é mais do mesmo. Depois da primeira aula que postei já tive umas 3 ou 4 aulas na faculdade, tudo com basicamente a mesma coisa. Resumi um pouco de tudo aqui. Se você entendeu a primeira aula, então não terá problemas para essa. O que farei aqui será apenas passar alguns exercícios e dar umas dicas para cada um. Se não viu ou não entendeu a primeira aula, basta dar uma olhada de novo clicando aqui.

Não sei se já disse isso, mas na faculdade, infelizmente, é usado o M$ SQL Server em todas as aulas o que acho uma enorme irresponsabilidade e falta de respeito. Irresponsabilidade porque acho que as faculdades deveriam ensinar com Software Livre, especialmente uma faculdade pública. E dai que pode sair de graça um software da Microsoft para as faculdade se no final quando os alunos se formarem eles terão que pagar por ele caso queiram usá-lo em suas empresas ou algo do tipo. Falta de respeito porque a M$ como tem sempre a mania de não seguir padrões e fazer as coisas bem diferentes de todos os outros (provavelmente para dificultar migrações e manter seu monopólio) e isso acaba criando alunos limitados e sem capacidade de usar outro software. Se querem ensinar usando o SQL Server tudo bem, mas pelo menos deveriam ter a finesse de ensinar como as mesmas coisas são feitas em outros bancos como o MySQL. Como sou um cara que acredita na liberdade e no Software Livre estudo e faço tudo usando ferramentas livres. Por enquanto são poucas as coisas que preciso mudar para fazer meus estudos de banco no MySQL, mas sei que a faculdade vai inventar de passar Trigger e essas outras coisas e que vão complicar na hora de estudar usando outro software que não seja o da M$. Quando isso acontecer vou procurar a forma correta de implementar essas coisas aqui no MySQL e dar um jeito de postar tudo aqui no blog (ou então simplesmente paro de postar as aulas de banco). Por enquanto quero dizer que as aulas de banco aqui do blog serão feitas usando o MySQL sempre. Ah, coloquei a foto do golfinho porque o golfinho é o símbolo do MySQL

Melhor eu parar de falar e começar com a aula!

Em primeiro lugar vamos abrir o MySQL. Se o serviço não estiver iniciado basta digitar em algum terminal:

sudo /etc/init.d/mysql start

Dentro do MySQL vamos criar um banco chamado aulas.

create database aula;

Agora vamos selecioná-lo:

use aula;

Criando as tabelas

Vamos agora criar as tabelas que usaremos para fazer os exercícios. Essas aulas não pretendem ensinar ou detalhar a criação de tabelas, portanto não vou falar nada sobre elas, apenas passar a “receita do bolo” aqui para não perdermos tempo na criação das tabela e podermos focar nos exercícios.

create table clientes(
cli_codigo int not null primary key,
cli_nome varchar(40) not null,
cli_cpf varchar(12) not null Unique);

create table vendedores(
ved_codigo int not null primary key auto_increment,
ved_nome varchar(40) not null,
ved_cpf varchar(12) not null unique);

create table pedidos(
ped_numero int not null primary key auto_increment,
ped_data datetime not null,
cli_codigo int not null,
ved_codigo int not null,
foreign key (cli_codigo) references clientes (cli_codigo),
foreign key (ved_codigo) references vendedores (ved_codigo));

create table produtos(
prd_codigo int not null primary key auto_increment,
prd_descricao varchar(50) not null,
prd_valor decimal(7,2),
prd_qtd int);

create table itens_pedidos(
ped_numero int not null,
prd_codigo int not null,
itp_qtd int not null,
itp_valor decimal(7,2) not null,
primary key (ped_numero, prd_codigo),
foreign key (ped_numero) references pedidos (ped_numero),
foreign key (prd_codigo) references produtos (prd_codigo));

Inserindo os dados nas tabelas

insert into clientes values (1, 'Superman', 100), (2, 'Porra Loka', 200), (3, 'Batiman', 300);

insert into vendedores values (1, 'Super Pinga', 10), (2, 'Super Cerva', 20), (3, 'Super Wine', 30);

insert into produtos values (1, 'Caneta', 3.2, 150), (2, 'Apontador', 0.75, 50), (3, 'CD', 1.15, 100);

insert into pedidos values (1, "2007/11/08 10:00:00",1,1), (2, "2007/12/08 11:00:00",2,2);

insert into itens_pedidos values (1, 1, 20, 1.2), (1, 2, 10, 30), (1, 3, 15, 0.78), (1, 4, 20, 3.5), (1, 5, 10, 0.6),  (1, 6, 20, 1.0), (2, 2, 30, 2.0), (3, 3, 5, 1.99);

Não reparem nos nomes e produtos usados aqui. Estou usando o que foi passado na aula. Tenho mais bom humor na hora de escolher os nomes de clientes, vendedores, produtos etc (uso nomes prováveis de filhos de empregadas domésticas, pedreiros, jogadores de futebol… Nome como Bucetildes, Robisvaldieldson Junior etc).

Exercícios

Agora que já está tudo pronto, vamos começar a fazer alguns exercícios. Estes primeiros são bem simples. Praticamente é a mesma coisa que foi passada na primeira aula. Só consultas com join (junção).

1. Consultar todos os pedidos
2. Consultar o nome do cliente do pedido 2
3. Consultar o nome do cliente e o nome do vendedor do pedido 1.
4. Consultar o nome de todos os produtos e quantidades vendidas do pedido 2.

Resolução dos exercícios

1. select * from pedidos;

2. select c.cli_nome, p.ped_numero
   from clientes c, pedidos p
   where c.cli_codigo = p.cli_codigo AND p.ped_numero = 2;

3. select c.cli_nome, v.ved_nome
   from clientes c, vendedores v, pedidos p
   where c.cli_codigo = p.cli_codigo AND v.ved_codigo = p.ved_codigo AND p.ped_numero = 1;

4. select p.prd_descricao, i.itp_qtd
   from produtos p, itens_pedidos i
   where p.prd_codigo = i.prd_codigo AND i.ped_numero = 2;

Antes de seguirmos…

Para os próximos exercícios será necessário usar SUM e COUNT, portanto tentarei explicar um pouco sobre essas funções aqui antes de seguirmos.

SUM

Essa função retorna a soma de uma expressão. É necessário também usarmos o GROUP BY quando usarmos o SUM. Ele funciona da seguinte maneira: Faz a conta que pedimos e depois agrupa as colunas que escolhemos com o GROUP BY.

Por exemplo: Se temos uma coluna chamada numero que ao fazermos uma consulta retorne 1, 1 e 2, ao usarmos o GROUP BY nessa coluna, os números repetidos serão agrupados e a consulta retornará 1, 2. Como os números repetidos foram agrupados, o SUM além de fazer a expressão que pedimos, somou as colunas que foram agrupadas.

COUNT

Conta o número de linhas ou dos valores das linhas. Depende de você. Basta pedir com jeitinho

Por exemplo, se temos a tabela jumentos (sim, imagine só os campos: jum_codigo, jum_nome, jum_cor) e nesta tabela temos 4 jumentos cadastrados, ao fazermos uma consulta usando count(*) da seguinte maneira:

select count(*) from jumentos;

Será feita a conta de quantos jumentos temos cadastrados no total. Obviamente será retornado o número 4.

Agora vamos imaginar que temos 2 jumentos diferentes mas com o mesmo nome. Podemos fazer nossa consulta de forma mais específica usando o group by:

select count(*)
from jumentos
group by jum_nome;

Então se tivermos 4 jumentos, um chamada Virgulino, outro chamada Mula Guerreira e 2 chamados Severino Calvacanti, a consulta retornaria 3 linhas, mostrando 1, 1 e 2, ou seja, mostrando que temos dois jumentos de nomes iguais.

GROUP BY

Acho que nem preciso falar muito sobre o GROUP BY já que usamos nos dois exemplos acimas. Ele agrupa o resultado em subconjuntos que possuem valores correspondentes em uma ou mais colunas.

Mais exercícios

Agora que já vimos SUM, COUNT e GROUP BY podemos passar para os próximos exercícios onde estas funções serão utilizadas.

1. Consultar os valore totais dos pedidos
2. Consultar o número de vendas de cada produto
3. Consultar o faturamento (total vendido) de cada produto

Resolução destes exercícios

1. select i.ped_numero, sum(i.itp_qtd * i.itp_valor)
   from pedidos p, itens_pedidos i
   where p.ped_numero = i.prd_codigo
   group by i.ped_numero;

2. select p.prd_codigo, count(*)
   from produtos p, itens_pedidos i
   where p.prd_codigo = i.prd_codigo
   group by i.prd_codigo;

3. select p.prd_codigo, p.prd_descricao, sum(i.itp_qtd * i.itp_valor) Faturamento
   from produtos p, itens_pedidos i
   where p.prd_codigo = i.prd_codigo
   group by p.prd_codigo, p.prd_descricao;

Um pouco sobre ORDER BY e HAVING

A cláusula ORDER BY (como o próprio nome dá a entender) serve para ordenar os registros em ordem crescente ou decrescente (você escolhe). Por padrão os valores são mostrados em ordem crescente. Podemos usar DESC, depois que inserimos o ORDER BY em nossa consulta para ordenarmos em ordem decrescente.

Exemplo: Temos a nossa tabela de jumentos e fazemos a mesma consulta que já foi mostrada antes, mas desta vez queremos ordenar pelo nome da mula. Normalmente seria ordenado por ordem alfabética, ou seja, se usarmos ORDER BY jum_nome, a famosíssima Mula Guerreira apareceria antes do nosso querido jumento Severino Cavalcanti, pois a letra M vem antes da letra S. Mas se quisermos fazer o Severino aparecer primeiro, basta fazer a consulta desta forma:

select count(*)
from jumentos
group by jum_nome
order by jum_nome desc;

O HAVING já serve para quando precisamos fazer algum teste lógico que não podemos usar no WHERE. Por exemplo, na mesma tabela de jumentos, usamos os exemplos com count(*) e group by jum_nome para vermos qual jumento tem o mesmo nome de outro. Se quisermos fazer um teste para mostrar em nossa consulta quantos jumentos com o mesmo nome aparecem duas ou mais vezes por exemplo, usamos o HAVING da seguinte forma:

select count(*)
from jumentos
group by jum_nome
having count(*) >= 2;

Devemos lembrar que o HAVING é aplicado em cima do agrupamento (GROUP BY). O HAVING é como se fosse um WHERE do agrupamento. Por isso não podemos usar HAVING sem GROUP BY (a menos que estejamos querendo um erro na consulta, e acho que ninguém quer isso :P).

Últimos exercícios desta aula (prometo)

1. Consultar a quantidade vendida de cada produto, apresentando em ordem decrescente
2. Consultar os produtos que foram vendidos em 2 ou mais pedidos
3. Consultar a quantidade de pedidos de cada cliente

Resolução dos últimos exercícios

1. select p.prd_codigo, p.prd_descricao, sum(i.itp_qtd) qtd_vendidas
   from produtos p, itens_pedidos i
   where i.prd_codigo = p.prd_codigo
   group by p.prd_codigo, p.prd_descricao
   order by qtd_vendidas desc;

2. select p.prd_codigo, p.prd_descricao, count(*) vendas
   from produtos p, itens_pedidos i
   where i.prd_codigo = p.prd_codigo
   group by p.prd_codigo, p.prd_descricao
   having count(*) >= 2
   order by vendas desc;

3. select c.cli_codigo, c.cli_nome, count(*) qtd_pedido
   from pedidos p, clientes c
   where c.cli_codigo = p.cli_codigo
   group by c.cli_codigo, c.cli_nome;

Bom galera, por enquanto é só! Podem recolher os materiais e irem para o recreio Até a próxima aula!

Update: Para o xarope do Danilo que comentou aqui, vou criar um link para o site do professor Sérgio da onde tem provavelmente as mesmas tabelas… O xarope vem comentar besteira aqui no blog e falar que fiz ctrl-c e ctrl-v do site do professor, mas na verdade ele apenas está mostrando ser semi-analfabeto com seu comentário, pois foi incapaz de ler o que disse que usei as tabelas e nomes que foram passados na aula pelo mesmo professor do site que me dá aula também e na época eu nem lembrava o endereço do site dele ou sabia que estaria no site essa mesma tabela. Danilo querido, larga de ser xarope e não reclama, pois eu disse que foi a tabela passada na aula. Aprenda a ler com calma antes de sair escrevendo besteira.

Ah, o site do professor Sérgio é esse: http://www.ensinalegal.com.br

Prontinho Danilo… Ficou feliz?

Technorati Tags: SQL, Banco de Dados, MySQL, database, banco, aula, segunda, segunda aula, join, junção, agrupamento, group by, cláusula, jumento, severino cavalcanti, mula guerreira, cedral, cedrar, vô kiko, sum, order by, having, order, where, insert, consulta, jumentos, mula, código, codigo, id, cod, exercícios, exercício, golfinho, dolphin, faculdade, escola, estudos, post, Software Livre, liberdade, blog, M$, SQL Server, $QL $erver, inserir, tabelas, table

Powered by ScribeFire.

Tags: Aulas by Terramel
9 Comments »

Tags: Música by Terramel
11 Comments »

Como já disse antes, o objetivo desta matéria é ajudar na elaboração de um plano de marketing. Outra coisa importante é que é uma bagagem a mais no curso para o perfil profissional. Um diferencial a mais para o mercado. O marketing é um exemplo de disciplina de fácil aplicação (praticamente pode ser aplicado em qualquer área).

O plano de marketing é uma forma de traçar estratégias para que os 4 Ps sejam bem explorados.

Um exemplo é o Andaló Gallery Center que é uma espécie de shopping aqui na minha cidade que já existe faz um bom tempo e nunca deu muito certo. Por que isso? Se chamamos aquele ambiente de shopping, o que vem à mente? Se aquilo é um shopping, pensamos no P de produto. Muitos vão ao shopping para passear, outros para fazer compras, outro para se alimentar etc. Shopping é um ambiente onde se pode fazer várias coisas. Mas e o Andaló Gallery Center? Qual imagem o povo tem daquele shopping? Aquilo parece mais uma espécie de galeria. Podem ser que as premissas de seu planejamento tenham sido erradas. O que precisamos estudar são formas de embasar nosso conhecimento e diminuir os riscos.

Por que muitos produtos que são lançados tem um sucesso incrível?

Muitos se lembram do Tamagoshi. Uma invenção fantástica que teve um ciclo de vida curto. Quando chegou ao mercado vendeu muito, mas depois parou…

Ser pioneiro ou ser seguidor?

Precisamos saber escolher quando devemos ser pioneiros e quando devemos ser seguidores.

Não é errado ser seguidor. O seguidor tem que ser rápido e ainda tentar superar o pioneiro. Talvez uma empresa seguidora não tenha um ganho tão grande, mas também não precisa de muito investimento em pesquisa.

Algumas empresas sabem não apenas ser pioneiras, mas também como atingir o público que deseja e tem condições de fazer o que é proposto. Para a Apple, por exemplo, vale a pena investir em design porque seu produto aporta este valor.

Merchandising

Outro exemplo com a Apple é a forma como é feito o merchandising de seu produto. A maioria dos filmes, por exemplo, tem um produto da Apple. Lembram do filme “Mensagem Para Você” com Tom Hanks e Meg Ryan? Sempre que passava um computador no filme, era da Apple. Alguém ai assiste ao seriado “House”? Quase sempre passa um iPod.

Marcas

Uma marca pode querer passar uma imagem de tradição, ou então querer mostrar jovialidade.

Na hora de criarmos uma marca é bom focar no que queremos que seja transmitido ao público. Nike, por exemplo, é a deusa grega da vitória. Seu slogan, “Just Do It!” (apenas faça!), é transmitido em seu símbolo que é uma espécie de visto que mostra que algo foi feito.

Propostas e Críticas

Devemos saber explicar de um ponto de vista conceitual porque algo não dá certo. Sem propostas não vamos para frente. Precisamos de idéias e também de críticas para saber o que precisa ser trabalho e melhorado.

Marketing: Estudo da troca de valor entre partes interessadas.
Valor: Benefícios adquiridos pela compra e/ou utilização de um produto
Produto: Conjunto de benefícios

Commodity

Podemos dizer que um produto é um commodity quando já é comum para todos. Se um produto se torna um commodity, seu valor passa a não ser mais o mesmo que era. Um exemplo de commodity são os telefones celulares que já são muito comuns (a menos, é claro, que estejamos tratando de um telefone que agrega mais funções e valores que os demais como, por exemplo, os Smartphones).

Um produto não é commodity quando é algo exclusivo, que poucos ostentam, quando sua compra não é feita apenas pelo seu consumo. Um exemplo que foi dado em aula foi de uma casa noturna daqui de Rio Preto chamada Vila Dionísio, onde alguns boyzinhos filhinhos de papai escrotos boiolinhas e frescos clientes compram uma cerveja que custa mais que R$200,00 simplesmente para poder mostrar para os outros que tem dinheiro para gastar naquilo -.-

A Wikipédia define define Commodity da seguinte forma: “…termo de língua inglesa que, como o seu plural commodities, é utilizado nas transações comerciais de produtos de origem primária nas bolsas de mercadorias. É uma referência aos produtos em estado bruto ou com pequeno grau de industrialização, de qualidade quase uniforme, produzidos em grandes quantidades e por diferentes produtores. Estes produtos “in natura”, cultivados ou de extração mineral, podem ser estocados por determinado período sem perda significativa de qualidade. Exemplos: borracha, ouro, aço, prata, cobre, soja e trigo. Também pode ser utilizado para referir-se a produtos sem diferenciação.”

Powered by ScribeFire.

Tags: Aulas by Terramel
6 Comments »

Saudações caro leitores! Este é o primeiro post de Computação Gráfica. Pelo que percebi esta disciplina na faculdade será mais focada no entendimento dos comandos de OpenGL. Nas palavras do professor está aula será basicamente um “teste de mesa”, ou seja, olhar o código do programa e interpretá-lo passo a passo tentando entendê-lo através dos comentários. Depois executaremos o programa e depois modificaremos alguns parâmetros e executaremos de novo para vermos o resultado das alterações que fizemos.

Nas aulas será feita também a modelagem de objetos, como por exemplo uma mesa, e depois juntaremos tudo e modelaremos uma parte da faculdade (é mole? ¬¬).

O que é OpenGL?

Antes de seguir o que foi passado em aula, acredito que seja mais importante explicar aqui o que é o OpenGL.

O OpenGL é uma biblioteca de rotinas gráficas de modelagem, manipulação de objetos e exibição tridimensional que permite a criação de aplicações que usam Computação Gráfica. Seus recursos permitem ao usuário criar objetos gráficos com qualidade, de modo rápido, além de incluir recursos avançados de animação, tratamento de imagens e texturas. É possível ter visualização de vários ângulos.

Entre os recursos gráficos disponíveis pelo OpenGL, podem ser destacados os seguintes:

• Modos de desenho de pontos;
• Ajuste de largura de linhas
• Aplicação de transparência
• Ativação de desativação de serrilhamento (aliasing)
• Mapeamento de superfícies com textura
• Seleção de janela de desenho
• Manipulação de fontes/tipos de iluminação e sombreamento
• Transformação de sistemas de coordenadas
• Transformações em perspectiva
• Combinação de imagens (blending)

As implementações do OpenGL geralmente provêem bibliotecas auxiliares, tais como a GLU (OpenGL Utility Library), utilizada para realizar tarefas comuns, tais como manipulação de matrizes, geração de superfícies e construção de objetos por composição.

As especificações do OpenGL não descrevem as interações entre OpenGL e o sistema de janelas utilizado (X Window, Ruindows etc). Assim, tarefas comuns em uma aplicação, tais como criar janelas gráficas, gerenciar eventos provenientes de mouse e teclado e apresentação de menus ficam a cargo de bibliotecas próprias de cada sistema operacional.

Referência: ine 5341

Algumas dicas

• Ler o código
• Se compreender o comando, passar para a próxima linha do programa
• Se o próximo comando for uma função, ler a função
• Se tiver alguma dúvida, esclarecê-la antes de passar para a próxima linha

O Programa

#include <stdio.h>
#include <stlib.h>
#include <GL/glut.h>
#include <GL/glu.h>

int projecao=0; // Variável Lógica para Definir o Tipo de Projeção (Perspectiva ou Ortogonal)
int posx=0, posy=10, posz=20; // Variáveis que definem a posição da câmera
int oy=0,ox=0,oz=0; // Variáveis que definem para onde a câmera olha
int lx=0, ly=1,  lz=0; // Variáveis que definem qual eixo estará na vertical do monitor.

void INIT(void)
{
	glClearColor(0.0, 0.0, 0.0, 0.0); // função que determina a cor utilizada para limpar a janela.
	glEnable(GL_BLEND); // Habilita Transparência na cena
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); // O primeiro parâmetro se refere ao objeto da frente (tomando como referência o observador). O segundo argumento define que o objeto mais próximo será responsável por uma fraçao igual ao quarto argumento do glColor no cálculo total das cores
	glShadeModel(GL_SMOOTH); // glShadeModel é usada para especificar a técnica de colorização desejada. GL_SMOOTH seleciona o sistema de preenchimeto, permitindo de gradiente de cores
}
void DISPLAY(void)
{
	glMatrixMode(GL_PROJECTION); // glMatrixMode()- define qual matriz será alterada. SEMPRE defina o tipo de apresentação (Ortogonal ou Perspectiva) na matriz PROJECTION.
	glLoadIdentity(); // "Limpa" ou "transforma" a matriz em identidade, reduzindo possíveis erros.
	if (projecao==1)
		glOrtho(-50, 50, -50, 50, -50, 50); // Define a projeção como ortogonal
	else
		gluPerspective(45,1,1,100); // Define a projeção como perspectiva

	glMatrixMode(GL_MODELVIEW); // glMatrixMode()- define qual matriz será alterada. SEMPRE defina a câmera (Ortogonal ou Perspectiva) na matriz MODELVIEW (onde o desenho ocorrerá).
	glLoadIdentity(); // "Limpa" ou "transforma" a matriz em identidade, reduzindo possíveis erros.
	gluLookAt(posx,posy,posz,ox,oy,oz,lx,ly,lz); // Define a pos da câmera, para onde olha e qual eixo está na vertical.
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // "limpa" um buffer particular ou combinações de buffers, onde buffer é uma área de armazenamento para informações da imagem. Nesse caso, está "limpando os buffers para suportarem animações.
	glPushMatrix(); // Salva o estado atual da cena. O que for desenhado após não influencia o já representado
	glColor3ub(100, 255, 40); //DEFINE cor (R, G, B e percentual de transparência para o objeto)
	glutSolidTeapot(5.0);
	glColor4f(0.9, 0.2, 0.9, 0.35); //DEFINE cor (R, G, B e percentual de transparência para o objeto)
	glutSolidCube(10.0);
	glPopMatrix();  //Retorna ao estado anterior da cena. O que for desenhado após o Push não influenciou o já representado
	glutSwapBuffers(); //Executa a Cena. SwapBuffers dá suporte para mais de um buffer, permitindo execução de animações sem cintilações.
}
void MOUSE(int botao, int estado, int x, int y)
{  // botão recebe o código do botão pressionado. estado recebe se está pressionado ou não. x e y recebem respectivamente as posições do cursor do mouse
	switch (botao)
	{
		case GLUT_LEFT_BUTTON:
		if (estado == GLUT_DOWN)
		{
			projecao=1;
			posx=0; posy=10; posz=20;
       			ox=0,oy=0,oz=0;
			lx=0, ly=1,lz=0;
			glutPostRedisplay();
      		}
		break;
		case GLUT_RIGHT_BUTTON:
		if(estado == GLUT_DOWN)
		{
			projecao=0;
			posx=0; posy=10; posz=20;
			oy=0; ox=0;  oz=0;
			lx=0, ly=1,lz=0;
			glutPostRedisplay();
		}
		break;
	}
}
void keyboard (unsigned char key, int x, int y)
{  // Key recebe o código ASCII da tecla. x e y recebem respectivamente as posições do cursor do mouse (permite tratar os dois dispositivos)
	if (key=='d') { lz=0; ly=1; ox+=5; }
	else if (key=='e') { lz=0; ly=1; ox-=5;	}
	else if (key=='c') { lz=0; ly=1; oy+=5;	}
	else if (key=='b') { lz=0; ly=1; oy-=5; }
	else if (key==27) { exit(0); }
	glutPostRedisplay();
}
void TeclasEspeciais (unsigned char key, int x, int y)
{  //Key - recebe o código ASCII da tecla. x e y recebem respectivamente as posições do cursor do mouse (permite tratar os dois dispositivos)
	if (key==GLUT_KEY_RIGHT) { posx+=5; ox+=5; }
	else if (key==GLUT_KEY_PAGE_UP) { posy+=5; oy+=5; }
	else if (key==GLUT_KEY_UP) { posz-=5; oz-=5; }
	else if (key==GLUT_KEY_LEFT) { posx-=5; ox-=5; }
	else if (key==GLUT_KEY_PAGE_DOWN) { posy-=5; oy-=5; }
	else if (key==GLUT_KEY_DOWN) { posz+=5; oz+=5; }
	glutPostRedisplay();
}
int main(int argc, char *argv[])
{
	glutInit(&argc, argv); //Dá suporte para diferentes SO.
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STENCIL); /* Avisa a GLUT que modo de exibição deve ser usado quando a janela é criada. GLUT_DOUBlE permite animações (sem cintilações). GLUT_RGB permite cores compostas por Vermelho, Verde e Azul. GLUT_STENCIL é o buffer que permite trablhar com profundidade e elimina faces escondidas.
	glutInitWindowSize(500, 500);
	glutInitWindowPosition(10, 10);
	glutCreateWindow("Estrutura para uma Aplicação 3D");
	INIT();
	glutDisplayFunc(DISPLAY);
	glutMouseFunc(MOUSE);
	glutKeyboardFunc(keyboard);
	glutSpecialFunc(TeclasEspeciais);
	glutMainLoop(); // Permite que a execução do programa continue
	return 0; // retorna falso para o SO, indicando que o programa foi finalizado.
}

A linguagem usada neste programa foi C. Para compilar usando o gcc basta abrir um terminal (xterm, por exemplo) e digitar:

gcc -o estrutura_basica -Wall -lglut -lGL -lGLU estrutura_basica.c

E para rodar basta digitar

./estrutura_basica

Comandos

GLUT_DOUBLE: Permite que a freqüência de apresentação não prejudique sua apresentação. Esse comando coloca mais de um buffer trabalhando para que não seja vista a cintilação. Se usarmos GLUT_SINGLE, acabamos vendo quadro a quadro.

GLUT_RGB: Define a cor que será trabalhada. RGB respectivamente significam red, green, blue (vermelho, verde, azul).

GLUT_DEPTH: Configura o ambiente para que o programa consiga representar animação com noção de profundidade.

GLUT_STENCIL: Habilita o gerenciamento de eliminação de superfície escondidas. Considera o ponto de vista do observador e o que está na frente pode ser visto, enquanto o que está atrás é eliminado. Respeita a hierarquia do ambiente (ou algo do tipo).

glutInitWindowSize: Define o tamanho da janela (em pixels).

glutInitWindowPosition: Define em qual posição da tela ele vai abrir a janela.

glutCreateWindow: Cria a janela

glClearColor: Limpa a janela com a cor que será usada. Os 3 primeiros valores definem respectivamente as cores vermelho, verde e azul (RGB) e o quarto valor define a transparência.

glEnable(GL_BLEND): Habilita a transparência. Enquanto glEnable é o comando que habilita alguma coisa, o GL_BLEND é a transparência que está sendo habilitada pelo glEnable.

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA): Trata a composição da cor do objeto tomando como ponto de referência o observador. O primeiro parâmetro se refere ao objeto de frente (tomando como referência o observador). O segundo define que o objeto será responsável por uma fração igual ao quarto argumento do glColor no cálculo total das cores.

glShadeModel(GL_SMOOTH): glShadeModel é usada para especificar a técnica de colorização desejada. GL_SMOOTH seleciona o sistema de preenchimento, permitindo gradiente de cores.

glutDisplayFunc: Faz o gerenciamento de uma função. No código visto neste post, o nome da função era Display, portanto o comando ficou da seguinte forma: glutDisplayFunc(DISPLAY). O nome da função pode ser qualquer um.

glutMouseFunc: Função que gerencia o mouse.

glutKeyboardFunc: Função que gerencia teclas comuns do teclado.

glutSpecialFunc: Função que gerencia teclas especiais do teclado como F1, F2, Esc, Enter etc.

glutMainLoop: Permite que a execução do programa continue.

glColor3ub: Define as cores (RGB).

glutSolidTeapot: Desenha um bule de chá.

glutWireTeapot: Desenha um bule de chá aramado.

glutSolidCube: Desenha um cubo

glutWireCube: Desenha um cubo aramado (se é que podemos chamar de aramado O.o)

Antes mesmo de fazer este post estava com um pressentimento de que essa aula não sairia da forma que eu queria. Realmente está muito vago isso e vou procurar melhorar nos próximos posts. Posso apenas dizer que isso é culpa da minha falta de conhecimento na matéria. Uma dica que posso dar (a mesma que o professor deu quando passou esta aula ¬¬) é que imprimam o código do programa que foi passado, peguem alguma apostila e/ou livro de OpenGL e façam uma boa leitura das funções. Por enquanto, fico na espera de comentários com sugestões, críticas, reclamações, dicas, dúvidas e, já que esta aula não saiu bem da forma como planejei, de uma turba de leitores enfurecidos com pedras nas mãos prontos para me apedrejar -.-

Technorati Tags: computação gráfica, computação, gráficos, gráfica, OpenGL, GL, jogos, filmes, animação, animações, placa de vídeo, vídeo, 3D, modelagem, objeto, ortogonal, perspectiva, teste de mesa, comandos, aulas, recursos, linhas, aliasing, pitch, pixel, glu, glut, API, X, Xwindow, Ruindows, janelas, windows, matrizes, superfícies, composição, library, bibliotecas, textura, blending, aliasing, desenho, linhas, pontos

Powered by ScribeFire.