Programação e Aplicações
Gráficas
UNIVERSIDADE DA BEIRA INTERIOR
Versão: 15 de Junho de 2007
Programação e Aplicações Gráficas
•
•
•
•
Scripts
Funções
Programação
Gráficos
– 2D
– 3D
– Animação
Scripts
– Script é um conjunto de comandos do
MATLAB gravados num ficheiro (com a
extensão .m chamados m-files).
– Para executar basta escrever o nome
do arquivo (sem a extensão .m).
– É equivalente a escrever todos os
comandos na janela principal, só que
armazenado num arquivo.
– Trabalha com variáveis globais
(apresentadas no directório de
trabalho)
Programação e Aplicações
Gráficas
• Ficheiros Scripts
Vamos escrever um script para resolver o seguinte
sistema linear de equações:
r   x1  2
5 2r
   
3 6

2
r

1
x

3




2


2 r  1 3r   x3  5
Ax=b, onde A depende de uma variável r.
Programação e Aplicações
Gráficas
• Exemplo de um script
>> r = 1
r=
1
>> solvex
det_A =
64
x=
-0.0312
0.2344
1.6875
Os valores do “det_A” e “x"
aparecem na janela porque
não tem ponto e vírgula no final
da linha correspondente
Programação e Aplicações
Gráficas
• Executando o script no MATLAB
– NUNCA grave o script com o mesmo nome de
uma variável nele inscrita.
– O nome do arquivo script deve começar por
uma letra.
– Seja cuidadoso com os nomes das variáveis
no script (todas essas variáveis são gravadas
no directório de trabalho)
Programação e Aplicações
Gráficas
• Cuidados que se deve ter:
Exercício 1
Faça um script que mostra na janela principal
uma tabela de conversão de graus Celsius
para graus Fahrenheit.
( Considere C=-40:5:100)
Exercício 2
Escreva um script que representa a função
tangente entre –pi/2 e pi/2 e insere o título e
legendas nos eixos.
Exercício 3
Construa um script que transforma um número x
em graus, num número y em radianos.
Funções
– Funções são m-files contendo um conjunto de
comandos do MATLAB, como um script, só
que todas as variáveis são locais e não
globais.
– São como programas ou subrotinas no Fortran.
– A 1ª linha do arquivo começa definindo as
variáveis de entrada e de saída, e o nome da
função.
– O nome da função deve ter o mesmo nome do
arquivo a ser gravado.
Programação e Aplicações
Gráficas
• Funções (function files)
– Crie uma estrutura lógica e pense na
sequência computacional antes de escrever o
código. Escreva-a num papel!!!
– Defina as variáveis de entrada e saída.
– Traduza o que escreveu no papel para o
MATLAB.
– Defina nomes lógicos para as variáveis e
funções.
– Escreva o máximo de comentários possíveis
no código.
– Divida grandes blocos computacionais e
escreva-os em funções separadas.
– Verifique os erros e a saída com mensagens
de erro e use o artifício do “;” para verificar os
passos intermédios de cálculo.
Programação e Aplicações
Gráficas
• Dicas para criação de funções
– O termo de definição deve ser escrito com letra
minúscula (“function” e não “Function”) .
– Os comentários começam com “%”, podendo
ser colocados em qualquer lugar. Todas as
linhas com comentários imediatamente após o
termo de definição são mostradas no MATLAB
help.
– Uma simples variável de saída não precisa ser
fechada por parênteses rectos [ ].
– O nome das variáveis de entrada e de saída na
linha do termo de definição são variáveis
locais.
Programação e Aplicações
Gráficas
• Cuidados que se deve ter:
• Para executar uma função
Considere uma função, cuja linha de definição é a
seguinte:
function [rho,H,F]
= motion(x,y,t);
>> [r,angmom,force] = motion(xt,yt,time);
>> [r,h,f] = motion(rx,ry,[0:100]);
>> [r,h,f] = motion(2,3.5,0.001);
>> [radius,h] = motion(rx,ry);
>> motion(xt,yt,t);
As variáveis xt, yt e time devem
ser definidas antes de executar
o comando.
As variáveis rx e ry devem ser
definidas antes de executar o
comando e t é especificada.
Todas as variáveis são
especificadas.
A terceira variável de entrada
tem que ser especificada dentro
da função. A terceira variável e
saída não é disponível.
Nenhuma variável de saída fica
disponível.
function [det_A,x]=solvex(r)
% SOLVEX Resolve um sistema de equações lineares de um matriz 3x3
% com parâmetro r.
% Para chamar esta função, digite:
% [det_A,x] = solvex(r)
% r é a entrada e det_A e x são as saídas
A = [5 2*r r; 3 6 2*r-1; 2 r-1 3*r]
b = [2;3;5];
det_A = det(A);
x = A\b;
>> [det_A,y] = solvex(1);
>> det_A
ans =
64
>> y
ans =
-0.0312
0.2344
1.6875
• Executando uma função dentro de outra
function [det_A,x]=solvex(r)
% SOLVEX Resolve um sistema de equações lineares de um matriz 3x3
% com parâmetro r.
% Para chamar esta função, digite:
% [det_A,x] = solvex(r)
% r é a entrada e det_A e x são as saídas
A = [5 2*r r; 3 6 2*r-1; 2 r-1 3*r]
b = [2;3;5];
det_A = det(A);
A
x = A\b;
função “det” é chamada
dentro da função solvex.
Porém, quando o nome da
função é dinâmico é feito de
forma diferente (use “feval”).
– pcode nomedoarquivo – protege o direito de
uso do código.
– profile – avalia a performance das funções.
profile on
[det_A,x] = solvex(r)
profile report
Programação e Aplicações
Gráficas
• Outros Comandos
• Exercício 1
Escreva uma função cuja entrada é um valor x
em graus e o converte para radianos.
• Exercício 2
Faça uma função que dadas 2 matrizes calcule a
soma e diferença.
• Exercício 3
Construa uma função que converte a pressão de
atm para N/m2.
Programação
Programação
– Conjunto de comandos usados para controlar
o fluxo das operações.
– Tipos:
(a) “for” e “while” – para “loops”
(b) “if-elseif-else” – estrutura condicional simples
(c) “switch-case-otherwise” – estrutura
condicional avançada
– Todos esses controladores de fluxo devem
terminar com “end”.
Programação e Aplicações
Gráficas
•
Fazendo “loops” – “for”
– Um “for” é usado para repetir uma operação
ou um grupo de operações para um número
fixo de vezes.
% Exemplo
for m=1:100
num = 1/(m+1)
end
% Exemplo
for n = 100:-2:0, k=1/(exp(n)), end
Programação e Aplicações
Gráficas
•
Fazendo “loops” – “while”
–
Um “while” é usado para repetir uma
operação ou um grupo de operações para um
número indefinido de vezes até que a
condição especificada pelo “while” seja
satisfeita.
% Exemplo
num = 1;
i = 1;
while num<10000
num = 2^i;
v = [i; num];
i = i + 1;
end
Programação e Aplicações
Gráficas
•
Condicional simples – “if-elseif-else”
– Cria blocos condicionais.
% Exemplo
i = 6; j = 21;
if i > 5
k = i;
elseif (i > 1) & (j == 20)
k = 5*i + j
else
k = 1;
end
Programação e Aplicações
Gráficas
•
•
Condicional avançado – “switch-caseotherwise”
% Exemplo 1
flag = 1;
switch flag
case 1
“1º bloco computacional”
case 2
“2º bloco computacional”
otherwise
“último bloco computacional”
end
Programação e Aplicações
Gráficas
– Cria blocos condicionais. Uma variável é usada
como um dispositivo de direccionamento
(switch), onde cada valor dessa variável
direcciona para um caso (case).
• Operadores
– Comparam os elementos correspondentes entre
duas matrizes da mesma dimensão
– Se for comparar uma matriz com um escalar
então compara cada elemento da matriz com o
escalar
– O resultado é uma matriz de 1 e 0
• Lógicos
– “&” ou “AND” ; “|” ou “OR” ; “~” ou “NOT” ;
“XOR”
– Devolve variável Booleana, 1 ou 0
Programação e Aplicações
Gráficas
• Relacionais
–
<, <=, >, >=, ==, ~=
– break – dentro de um “for” ou “while”, termina a
execução de um “loop” - ciclo.
– error(‘mensagem’) – dentro de uma função ou
script, sai da execução da rotina e mostra uma
mensagem de erro.
– return - dentro de uma função ou script, sai da
execução da rotina.
Programação e Aplicações
Gráficas
• Comandos de paragem
Exemplos - break
% Exemplo 1
u = [2 4 8 4 -1 2]; v = u;a=0;
for i = length(v)
if u(i) < 0; % check para u negativo
break
% termina a execução do loop
end
a = a + v(i)
end
Programação e Aplicações
Gráficas
•
Exemplos - error
function c = crossprod(a,b)
% Calcula o prod. Escalar de dois vectores
if nargin ~= 2 % se não for 2 variáveis de entrada
error('São necessárias duas variáveis de entrada')
end
if length(a) == 3 & length(b) == 3 % começa o cálculo
c = cross(a,b);
else
error('Os vectores devem ter dimensão 3')
end
Programação e Aplicações
Gráficas
•
Exemplos - return
x = exp(sqrt(163))
n = input(‘ Escreva o número max de iterações n=')
while n >= 1
if n <=0
return
end
x = log(x)
n = n - 1;
end
Programação e Aplicações
Gráficas
•
– input(‘mensagem’, opção) – mostra um texto
na janela de comandos e espera que o
utilizador introduza uma entrada pelo teclado.
– menu(‘Título’,‘opção1’, ‘opção2’,...) – cria um
menu na janela de comandos e efectua as
opções do menu.
– pause – pára a execução da rotina e espera
um sinal do utilizador ou efectua uma pausa
durante um determinado tempo (“pause(n)”).
Programação e Aplicações
Gráficas
• Outros comandos
Exercício 1
Faça um programa que verifica se um número é
primo.
Exercício 2
Um fornecedor faz o seguinte desconto num
determinado produto: mais de 200 unidades
7%; de 100 a 200 uni. 5%; de 50 a 100 uni.
3%; menos de 50 unidades tem desconto.
Escreva um programa que calcula o preço total
dado o nº. de unidades e o preço unitário.
Exercício 3
Altere os programas dos capítulos anteriores de
modo que peçam as entradas de modo
interactivo.
• Entrada e Saída
– O MATLAB possui algumas funções para ler e
escrever dados em arquivos do tipo binário ou
ASCII formatados.
– As funções são:
– fopen: abre um arquivo existente ou cria um novo
arquivo
– fclose: fecha um arquivo aberto
– fwrite: escreve uma informação binário para um arquivo
– fread: lê informação binário num arquivo
– fscanf: lê informação formatada num arquivo
– fprintf: escreve informação formatada num arquivo
Programação e Aplicações
Gráficas
Arquivos de entrada e
saída
Formato
Descrição
%c
Simples caracter
%d
Notação decimal
%e
Notação exponencial (usando “e” minúsculo )
%E
Notação exponencial (usando “e” maiúsculo )
%f
Notação fixando ponto
%g
O mais compactado de %e ou %f
%o
Notação Octal
%s
Grupos de caracteres
%x
Notação Hexadecimal
Programação e Aplicações
Gráficas
• Formatação de arquivos
Exercício 1
Construa um programa que escreve num ficheiro
de texto uma tabela de conversão entre as
unidades de temperatura Fahrenheit, Kelvin e
Celsius.
Exercício 2
Crie um programa que gera aleatoriamente um
conjunto de 100 elementos normalmente
distribuídos e os escreva num ficheiro.
Exercício 3
Faça um programa que lê o ficheiro da alínea
anterior, calcule a média dos dados e
apresente um gráfico dos valores lidos.
Exemplos – Escrever num arquivo
F = -40:5:100;
C = (F-32)*5/9;
t = [F;C];
fid = fopen('temperatura.tab','w');
fprintf(fid,'
Tabela de Temperatura\n');
fprintf(fid,'~~~~~~~~~~~~~~~~~~~~~~~~\n');
fprintf(fid,'Fahrenheit Celsius\n');
fprintf(fid,' %4i
%8.2f\n',t);
fclose(fid);
Programação e Aplicações
Gráficas
•
Exemplos – Ler um arquivo
fid = fopen('temperatura.tab');
lixo=fscanf(fid,'%25c',[1 1])
lixo=fscanf(fid,'%25c',[1 1])
lixo=fscanf(fid,'%20c',[1 1])
temp = fscanf(fid,'%i %f',[2 inf])
fclose(fid);
Programação e Aplicações
Gráficas
•
Gráficos
Gráficos
– Boas ferramentas de visualização;
– Gráficos 2D, 3D e animações;
– Especial sobre a parte gráfica do MATLAB é
fácil o uso e expansibilidade.
Programação e Aplicações
Gráficas
•
Gráficos 2D
– O comando básico e talvez o mais proveitoso
para produzir um gráfico em 2 dimensões é:
plot(xvalores,yvalores,’estilo-opções’)
Programação e Aplicações
Gráficas
•
Opções de estilo
Cor
linha
Descrição
y (amarelo)
- (sólido)
+ (sinal de soma)
m (margenta)
-- (tracejado)
o (cículo)
c (ciano)
: (pontinhado)
* (asterisco)
r (vermelho)
-. (tracejado-potinhado)
x (sinal x)
g (verde)
. (ponto)
b (azul)
^ (triangulo)
w (branco)
s (quadrado)
k (preto)
d (diamante), etc
Programação e Aplicações
Gráficas
•
Controle do eixo
– Pode-se mudar os limites dos eixos com o
comando “axis”
axis([xmin xmax ymin ymax])
Programação e Aplicações
Gráficas
•
Outras opções do comando “axis”
– axis(‘equal’) – coloca uma escala igual em
ambos os eixos
– axis(‘square’) – transforma a área do gráfico
rectângular num quadrado
– axis(‘normal’) – restaura os eixos para valores
padrões
– axis(‘off’) – remove a área do gráfico e
legendas
Programação e Aplicações
Gráficas
•
Inserindo textos nos gráficos
–
–
–
–
xlabel(‘eixo x’) – legenda do eixo x
ylabel(‘eixo y’) – legenda do eixo y
title(‘título’) – título do gráfico
text(2,6,‘texto’) – escreve ‘texto’ na
coordenada (2,6)
– legend(‘texto1’, ‘texto2’, ...)
Programação e Aplicações
Gráficas
•
Exercício
– Fazer o gráfico da função seno em conjunto
com duas funções de aproximação por série
de Taylor (1ª e 3ª ordem). As funções são:
y1 = sen(t)
y2 = t
y3 = t-t3/3!+t5/5!
Usando as funções xlabel, ylabel, axis, gtext,
hold on, plot...
Programação e Aplicações
Gráficas
•
Exercício (solução)
x=linspace(0,2*pi,100);
y1=sin(x);
plot(x,y1)
hold on
y2=x;
plot(x,y2,‘--’)
y3=x-(x.^3)/6+(x.^5)/120;
plot(x,y3,‘o’)
axis([0 5 -1 5])
Hold off
Programação e Aplicações
Gráficas
•
•
Gráficos especiais em 2D
– fplot
Aula 03
30
» fplot('x.*sin(x)',[0 10*pi])
20
10
0
-10
-20
-30
0
5
10
15
20
25
30
•
Gráficos especiais em 2D
– semilogx
7
» t=linspace(0,2*pi,200);
6
» x=exp(-t);
5
» y=t;
4
» semilogx(x,y), grid
3
2
1
0
-3
10
-2
10
-1
10
0
10
•
Gráficos especiais em 2D
– semilogy
3
10
» t=linspace(0,2*pi,200);
» semilogy(t,exp(t)), grid
2
10
1
10
0
10
0
1
2
3
4
5
6
7
•
Gráficos especiais em 2D
– loglog
6
10
» t=linspace(0,2*pi,200);
» x=exp(t);
5
10
» y=100+exp(2*t);
» loglog(x,y), grid
4
10
3
10
2
10
0
10
1
10
2
10
3
10
•
Gráficos especiais em 2D
– polar
90
» t=linspace(0,2*pi,200);
» r=sqrt(abs(2*sin(5*t)));
» polar(t,r)
1.5
60
120
1
30
150
0.5
180
0
330
210
300
240
270
•
Gráficos especiais em 2D
– fill
» t=linspace(0,2*pi,200);
» r=sqrt(abs(2*sin(5*t)));
» x=r.*cos(t);
» y=r.*sin(t);
» fill(x,y,'k')
» axis(‘equal')
1
0.5
0
-0.5
-1
-1.5
-1
-0.5
0
0.5
1
1.5
•
Gráficos especiais em 2D
– bar
1.4
» t=linspace(0,2*pi,200);
» r=sqrt(abs(2*sin(5*t)));
» y=r.*sin(t);
» bar(t,y)
» axis([0 pi 0 inf])
1.2
1
0.8
0.6
0.4
0.2
0
0
0.5
1
1.5
2
2.5
3
•
Gráficos especiais em 2D
– errorbar
1
» x=0:0.1:2;
» aprx2=x-x.^3/6;
» er=aprx2-sin(x);
» errorbar(x,aprx2,er)
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
-0.5
0
0.5
1
1.5
2
2.5
•
Gráficos especiais em 2D
– barh
» cont=char('Asia','Europa','Africa','America do Norte', 'America do Sul');
» pop=[3332;696;694;437;307];
» barh(pop)
População do Mundo (1992)
» for i=1:5,
America do Sul
5
gtext(cont(i,:));
end
America do Norte
4
» xlabel('Polulação em Milhões')
» title('População do Mundo (1992)')
3
Africa
2
Europa
Asia
1
0
500
1000
1500
2000
Polulação em Milhões
2500
3000
3500
•
Gráficos especiais em 2D
– plotyy
4
» x=1:0.1:10;
» y1=exp(-x).*sin(x);
» y2=exp(x);
» Ax=plotyy(x,y1,x,y2)
72.0021 74.0096
» hy1=get(Ax(1),'ylabel');
» hy2=get(Ax(2),'ylabel');
» set(hy1,'string','e^-x*sin(x)');
» set(hy2,'string','e^x');
0.4
0.3
2
0.2
1.5
0.1
1
ex
e-x*sin(x)
Ax =
x 10
2.5
0.5
0
-0.1
1
2
3
4
5
6
7
8
9
0
10
•
Gráficos especiais em 2D
– area
0.4
0.2
0
sin(x)./x
» x=linspace(-3*pi,3*pi,100);
» y=-sin(x)./x;
» area(x,y)
» xlabel('x')
» ylabel('sin(x)./x')
» hold on
» x1=x(46:55);
» y1=y(46:55);
» area(x1,y1,'facecolor','y')
-0.2
-0.4
-0.6
-0.8
-1
-8
-6
-4
-2
0
x
2
4
6
8
•
Gráficos especiais em 2D
– pie
» cont=char('Asia','Europa','Africa','America do Norte', 'America do Sul');
» pop=[3332;696;694;437;307];
» pie(pop)
America do Sul
6%
» for i=1:5,
8% America do Norte
gtext(cont(i,:));
end
13% Africa
61%
Asia
13% Europa
•
Gráficos especiais em 2D
– stairs
» t=linspace(0,2*pi,200);
» r=sqrt(abs(2*sin(5*t)));
» y=r.*sin(t);
» stairs(t,y)
» axis([0 pi 0 inf])
1.4
1.2
1
0.8
0.6
0.4
0.2
0
0
0.5
1
1.5
2
2.5
3
•
Gráficos especiais em 2D
– stem
» t=linspace(0,2*pi,100);
» f=exp(-0.2*t).*sin(t);
» stem(t,f)
1
0.8
0.6
0.4
0.2
0
-0.2
-0.4
0
1
2
3
4
5
6
7
•
Gráficos especiais em 2D
– compass
» zx=cos(th);
» zy=sin(th);
» z=zx+i*zy;
» compass(z)
90
1
120
60
0.8
0.6
150
30
0.4
0.2
180
0
210
330
240
300
270
•
Gráficos especiais em 2D
– Comet (faz uma pequena animação)
» q=linspace(0,10*pi,200);
» y=q.*sin(q);
» comet(q,y)
•
Gráficos especiais em 2D
– contour
» r=-5:0.2:5;
» [X,Y]=meshgrid(r,r);
» Z=-0.5*X.^2 + X.*Y + Y.^2;
» cs=contour(X,Y,Z);
» clabel(cs)
5
20
30
4
3
10
2
1
-10
0
0
-1
-2
10
0
-3
20
-10
-4
-5
-5
30
-4
-3
-2
-1
0
1
2
3
4
5
•
Gráficos especiais em 2D
– quiver
» r=-2:0.2:2;
» [X,Y]=meshgrid(r,r);
» Z=-0.5*X.^2 + X.*Y + Y.^2;
» [dx,dy]=gradient(Z,.2,.2);
» quiver(X,Y,dx,dy,2);
2.5
2
1.5
1
0.5
0
-0.5
-1
-1.5
-2
-2.5
-2.5
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
2.5
•
Gráficos especiais em 2D
– quiver
» r=-2:0.2:2;
» [X,Y]=meshgrid(r,r);
» Z=-0.5*X.^2 + X.*Y + Y.^2;
» pcolor(Z)
» axis('off')
» shading interp
Gráficos Múltiplos
– Se pretender fazer alguns gráficos e
colocá-los lado a lado (sem sobrepor
gráficos), use o comando “subplot”:
subplot(m,n,p)
Dividi a janela em m x n sub-janelas, e desenha
o gráfico na sub-janela p.
Programação e Aplicações
Gráficas
•
Plots 3D
– O comando básico para produzir uma curva
em 3 dimensões é:
plot3(x,y,z,’estilo-opções’)
Use agora o comando “zlabel”
Programação e Aplicações
Gráficas
•
•
Ângulo de visão
Aula 03
– view(azimute,elavação) –
onde o azimute é em
graus partir do eixo y
sendo o sentido antihorário o sentido positivo,
e a elevação em graus é o
ângulo medido a partir do
plano x-y.
– rotate3d on – mais versátil
e de fácil uso.
Gráfico de superfícies
– Os comandos básicos para fazer um gráfico
de uma superfície são: mesh e surf.
– Utilize o comando “meshgrid” para gerar uma
grelha de pontos quadrangular.
mesh(X,Y,Z)
surf(X,Y,Z)
Programação e Aplicações
Gráficas
•
•
Superfícies em 3D
– mesh e surf
>> x=linspace(-3,3,100);
>> [X,Y]=meshgrid(x,x);
>> Z=X.*Y.*(X.^2-Y.^2)./((X.^2+Y.^2));
>> mesh(X,Y,Z)
>> surf(X,Y,Z)
>> mesh(X,Y,Z)
•
Especiais em 3D
– fill3
» X=[0 0 0 0;1 1 -1 1;1 -1 -1 1];
» Y=[0 0 0 0; 4 4 4 4; 4 4 4 4];
» Z=[0 0 0 0; 1 1 -1 -1; -1 1 1 -1];
» fill3(X,Y,Z,rand(3,4))
» view(120,30)
1
0.5
0
-0.5
-1
-0.5
-1
0
0
1
2
0.5
3
4
1
•
Especiais em 3D
– contour3
» r=linspace(-3,3,50);
» [x,y]=meshgrid(r,r);
» z=-5./(1+x.^2+y.^2);
» contour3(x,y,z)
0
-1
-2
-3
-4
-5
2
0
-2
-3
-2
-1
0
1
2
3
•
Especiais em 3D
– surfc
» u=-5:0.2:5;
» [X,Y]=meshgrid(u,u);
» Z = cos(X).*cos(Y).*exp(-sqrt(X.^2+Y.^2)/4);
» surfc(X,Y,Z)
» axis('off')
•
Especiais em 3D
– surfl
» u=-5:0.2:5;
» [X,Y]=meshgrid(u,u);
» Z = cos(X).*cos(Y).*exp(-sqrt(X.^2+Y.^2)/4);
» surfl(X,Y,Z)
» shading interp
» colormap hot
•
Especiais em 3D
– meshz
» x=linspace(-3,3,50);
» y=x;
» [x,y]=meshgrid(x,y);
» z=-5./(1+x.^2+y.^2);
» meshz(x,y,z)
•
Especiais em 3D
– waterfall
» x=linspace(-3,3,50);
» y=x;
» [x,y]=meshgrid(x,y);
» z=-5./(1+x.^2+y.^2);
» waterfall(x,y,z)
» hidden off
0
-1
-2
-3
-4
-5
4
2
4
2
0
0
-2
-2
-4
-4
•
Especiais em 3D
– pie3
» pop=[3332;696;694;437;307];
» pie3(pop)
» title('população do mundo')
população do mundo
6%
8%
13%
13%
61%
•
Especiais em 3D
– stem3
» t=linspace(0,6*pi,200);
» x=t;
» y=t.*sin(t);
» z=exp(t/10)-1;
» stem3(x,y,z)
6
5
4
3
2
1
0
20
10
20
15
0
10
-10
5
-20
0
•
Especiais em 3D
– ribbon
» t=linspace(0,5*pi,100);
» y=sin(t);
» ribbon(t,y,0.1)
1
0.5
0
-0.5
-1
20
1.1
15
1.05
10
1
5
0.95
0
0.9
•
Especiais em 3D
– sphere
» sphere(20)
ou
» [x,y,z]=sphere(20);
» surf(x,y,z)
» axis('equal')
•
Especiais em 3D
– cylinder
» z=0:0.02:1;
» r=sin(3*pi*z)+2;
» cylinder(r)
•
Especiais em 3D
– slice
» v=[-3:0.2:3];
» [x,y,z]=meshgrid(v,v,v);
» f=(x.^2+y.^2-z.^2);
» xv=[-2 2.5];
» yv=2.5;
» zv=0;
» slice(x,y,z,f,xv,yv,zv)
» view(-30,30)
» xlabel('x')
» ylabel('y')
» zlabel('z')
» colorbar(‘horiz’)
•
Representando gráficamente
informações volumétricas
– As funções disponíveis para visualização de
informação volumétrica são: “slice”,
“isosurface”, “isonormal”, “isocaps”,
“subvolume”, “reducevolume”, “smooth3”,
“reducepatch”. Veja helpdesk para mais
informações.
•
Gráfico de superfícies interpoladora
– Muitas vezes, nós temos alguma informação
em forma (x,y,z) e queremos ajustar uma
superfície a essa informação. Para isso
usamos o comando “griddata”.
[Xi,Yi,Zi]=griddata(x,y,z,xi,yi,‘método)
•
Gráfico de superfícies interpoladoras
» xv=2*rand(1,100)-1;
» yv=2*rand(1,100)-1;
» zv=3./(1+xv.^2+yv.^2);
» stem3(xv,yv,zv)
3
2.5
2
1.5
1
0.5
0
1
0.5
1
0.5
0
0
-0.5
-0.5
-1
-1
•
Gráfico de superfícies interpoladoras
» xi=linspace(-1,1,30);
» yi=xi;
» [xi,yi]=meshgrid(xi,yi);
» [Xi,Yi,Zi]=griddata(xv,yv,zv,xi,yi,'v4');
» surf(Xi,Yi,Zi)
•
Handle Graphics
– O que é um handle?
São números associados a todos os objectos de
uma figura.
Hierarquia dos objectos gráficos:
•
Propriedade dos objectos
» h=plot(1:20)
h=
1.0056
» get(h)
Color = [0 0 1]
EraseMode = normal
LineStyle = LineWidth = [0.5]
Marker = none
MarkerSize = [6]
MarkerEdgeColor = auto
MarkerFaceColor = none
XData = [ (1 by 20) double array]
YData = [ (1 by 20) double array]
ZData = [] ...
•
Propriedade dos objectos
» h=plot(1:20)
h=
1.0056
» set(h,'Linewidth',2) %muda a espessura da linha
» set(h,'Color',[0 1 1]) %muda a cor da linha
•
Animação (Fazer um filme)
nframes = 36;
Frames = moviein(nframes);
angulo = linspace(0,360,36);
x=linspace(-3,3,100);
[X,Y]=meshgrid(x,x);
Z=X.*Y.*(X.^2-Y.^2)./((X.^2+Y.^2));
mesh(X,Y,Z)
for i=1:nframes
view(angulo(i),30)
Frames(:,i)=getframe;
end
movie(Frames,2)
Programação e Aplicações
Gráficas
Animação (Fazer um filme)
•