Escolar Documentos
Profissional Documentos
Cultura Documentos
Esta é a página do curso avançado de Matlab, elaborado pelo professor Diego da Silva de
Medeiros dentro do projeto intitulado MATLAB - Software de estudos matemáticos. Este curso
visa complementar o primeiro curso, de nível básico, com técnicas mais avançadas. O curso foi
dividido de 3 encontros de 2 horas:
Nesta aula, conceitos do Matlab não compreendidos no curso básico serão apresentados:
Indexação de matrizes
Classes de dados
Funções
Exceções
Exercícios
Nesta aula, a criação de interfaces gráficas simples para scripts será apresentada.
Botões de ação
Eixos
Campos de texto
Radiobuttons
Negativo da imagem
Brilho
Contraste
Binarização
Marca d'água
Suavização
Detecção de bordas
Paleta de cores
Tabela de conteúdo
[esconder]
1 Curso Matlab aplicado ao processamento de imagens - Aula 1
1.2.1 Char
1.2.2 Cell
1.2.2.1 O problema
1.2.3 Structs
1.3 Funções
1.4 Exceções
1.5 Exercício
3.1.4 Binarização
3.1.6 Suavização
Indexação de matrizes
Indexação simples
>> lin(1)
ans =
>> col(1)
ans =
Da mesma forma, podemos acessar o primeiro elemento da matriz (linha 1, coluna 1):
>> mat(1,1)
ans =
Repare que para o Matlab, o primeiro elemento de uma variável é o elemento de número 1.
Isso vai contra algumas linguagens de programação, como o C, onde o primeiro elemento é o
de número 0.
Indexação múltipla
Podemos também acessar mais de um elemento de vetores, passando um vetor como índice:
ans =
1 3
ans =
Repare que a configuração dos elementos retornados (linha ou coluna) segue a configuração
dos vetores originais. Para acessar mais de um elemento de uma matriz, passamos dois
vetores, um com as linhas e o outro com as colunas:
2 4
6 8
Uso do ":"
Tanto para matriz quanto para vetores, podemos usar o operador dois pontos para facilitar a
sintaxe:
>> col(1:3)
ans =
ans =
2 3 4
6 7 8
Neste caso, como a matriz mat tem apenas duas linhas, poderíamos substituir
o 1:2 simplesmente pelos dois pontos:
ans =
2 3 4
6 7 8
O comando end
Muitas vezes não sabemos o número total de elementos de um vetor ou de uma matriz, e
queremos pegar todos os elementos a partir de uma determinada posição. Para isso há a
facilidade do comando end, que indica que os dados da variável deverão ser tomados até o
último elemento:
ans =
2 3 4
6 7 8
Ao ler os comandos acima, repare que há então formas diferentes de se indexar uma variável:
um vetor recebe apenas um número, que indica o número do elemento, e uma matriz recebe
dois números, que indica a linha e a coluna do elemento. Quando passamos apenas um
número dizemos que estamos escolhendo os elementos pelo seu índice, e quando passamos
dois ou mais números estamos escolhendo os elementos pelo seu subscrito. Esse é um fator
de confusão no Matlab, pois podemos inverter as coisas e escolher elementos de um vetor
via subscrito e elementos de uma matriz via índice:
>> lin(1,3)
ans =
>> col(2,1)
ans =
>> mat(4)
ans =
6
Assim, é selecionado o elemento da linha 1 e coluna 3 do vetor lin, o elemento da linha 2 e
coluna 1 do vetor col. No caso da matriz, como o número de dimensões da variável é maior
que o número de números passados, o Matlab entende que os elementos estão sendo
selecionados via índice, e conta, coluna a coluna, os índices dos elementos até chegar o índice
desejado. Como estamos selecionando o elemento 4 da matriz, o matlab passa os elementos
mat(1) = 1, mat(2) = 5, mat(3) = 2 e para no mat(4) = 6. Isso pode ser visto ao selecionar os
elementos de 1 a 4 da matriz:
>> mat(1:6)
ans =
1 5 2 6 3 7
Repare que o resultado da seleção dos elementos de 1 a 4 da matriz é um vetor linha com os
valores de mat(1,1), mat(2,1), mat(1,2), mat(2,2), mat(1,3) e mat(2,3). Porém, ao usar a
escolha pelo índice, podemos também receber um vetor coluna, desde que o vetor usado
como índice seja um vetor coluna:
ans =
ans =
1 5
2 6
3 7
ou mesmo ter, a partir de um vetor, uma matriz como resultado:
ans =
5 7
6 8
5 8
6 7
Classes de dados
No curso de nível básico, classes numéricas de dados foram estudados. Nesta etapa iremos
conhecer outras classes existentes:
Char
Nos dados de tipo char estão compreendidos os caracteres textuais. Para indicar que uma
variável é do tipo char, usamos aspas simples:
var1 =
Da mesma forma que números, vetores de dados char podem ser criados:
var2 =
abc
Repare que um vetor de caracteres é uma string, e a sua criação pode ser feita diretamente,
inclusive sem os colchetes:
var3 =
ola amiguinhos!
O Matlab faz uso da Tabela ASCII quando um número é concatenado à um dado da classe char:
var4 =
a#
Porém, é possível converter o número em um vetor char, não realizando a conversão. Para isso
é usada a função num2str:
var5 =
a35
Cell
O problema
Muitas vezes, queremos criar listas de nomes, e a primeira opção que temos é usar strings:
lista1 =
Jose Aparecido
Maria Silveira
Etevaldo Mario
Este tipo de solução, porém, funciona apenas quando todas as strings tem o mesmo número
de caracteres, pois em suma, o que estamos fazendo é uma matriz de dados do tipo char:
>> size(lista1)
ans =
3 14
Se tentarmos criar uma lista com strings de tamanhos diferentes, estamos criando uma matriz
com número de elementos incompletos, sendo retornado um erro:
A classe cell
Para resolver este e outros problemas, o Matlab disponibiliza uma classe de dados adicionais,
a cell. O tipo cell é como um invólucro que armazena dados de outros tipos do Matlab. Sua
criação é feita usando chaves ao invés de colchetes:
celula1 =
[5]
celula2 =
'b'
celula3 =
[1x5 double]
celula4 =
'boa noite'
Repare que todas as variáveis criadas são do tipo cell, independente de estarem armazenando
números ou letras:
Além disso, todas as variáveis criadas tem o mesmo tamanho, 1x1. Porém, assim como
qualquer outro tipo de dado do Matlab, vetores ou matrizes podem ser criados.
celula5 =
celula6 =
'g'
'y'
'A'
celula7 =
celula8 =
'oi' 'amigo'
>> celula9 = {'Joao', 13, 'O+', [140, 35]; 'Maria', 15, 'A-', [135, 29]}
celula9 =
Structs
As cells permitem criar listas com tipos diferentes de dados e com diferentes tamanhos.
Porém, é algumas vezes necessária a criação de listas mais elaboradas. Para
isso, structs podem ser utilizadas. Para criar um dado do tipo struct, pode-se usar a
função struct:
>> s1 = struct('Nome',[],'Idade',[],'Tipo',[],'Altura',[],'Peso',[])
s1 =
Nome: []
Idade: []
Tipo: []
Altura: []
Peso: []
Neste caso, uma struct com 5 campos foi criada, porém, nenhum valor foi atribuído à nenhum
dos campos. Para adicionar valores, o operador ponto é utilizado:
s1 =
Nome: 'Joao'
Idade: []
Tipo: []
Altura: []
Peso: []
s1 =
Nome: 'Joao'
Idade: []
Tipo: []
Altura: 140
Peso: []
É possível atribuir valores já na criação da struct, bastando incluir no lugar dos colchetes. Além
da função struct é possível criar variáveis desta classe dinamicamente, através do operador
ponto:
s2 =
Marca: 'Volkswagen'
>> s2.Modelo = 'Fusca'
s2 =
Marca: 'Volkswagen'
Modelo: 'Fusca'
s2 =
Marca: 'Volkswagen'
Modelo: 'Fusca'
Ano: 1962
s2 =
Marca
Modelo
Ano
Funções
Assim como a maioria das linguagens de programação o Matlab também permite a criação de
funções. Com elas, evitamos a repetição de códigos numa simulação, contribuindo para a
legibilidade e facilitando a alteração de funcionalidade. Para criar uma função criamos um
arquivo com o nome pretendido e incluímos um cabeçalho que indica as suas características.
Por exemplo, arquivo soma1.m:
function y = soma1(x)
y = x + 1;
end
Este arquivo cria uma função que soma 1 à um número. Esse número é passado como
argumento da função (x), e o resultado da soma é retornado através da variável y. O
comando end ao fim do arquivo é neste caso opcional. Após salvar as alterações no arquivo,
basta chamar a função pelo seu nome e lista de argumentos:
>> soma1(2)
ans =
>> soma1(5)
ans =
>> soma1(1998)
ans =
1999
Uma função também pode receber e retornar mais de um valor. Neste caso, o seu cabeçalho
fica um pouco diferente:
subt = x1 - x2;
mult = x1 * x2;
divs = x1 / x2;
end
Esta função recebe dois números (x1 e x2) e realiza 4 operações. Cada operação é retornada
numa variável diferente. Um detalhe importante é que o acesso aos múltiplos retornos da
função se dá apenas via atribuição à variáveis específicas. Do contrário, apenas a primeira
variável (no caso, a soma) é retornada:
>> operacoes(1,2)
ans =
soma =
subt =
-1
soma =
3
subt =
-1
mult =
divs =
0.5000
Todas as variáveis criadas dentro de uma função são visíveis apenas à ela. São variáveis locais.
Da mesma forma, uma função acessa do workspace apenas as variáveis que lhe foram
passadas como argumento. É possível estender o uso de uma variável do workspace para
qualquer função, usando para isso o comando global. Após a execução do comando global var,
a variável var poderá ser usada por qualquer função.
Funções inline
f=
Inline function:
f(x,y) = x + y
No quadro acima, a função f(x,y), que calcula a soma da variável x com a variável y foi criada. A
função é acessada a partir da variável ao qual ela foi atribuída (neste caso, f), e parâmetros são
passados como uma função qualquer:
>> f(1,2)
ans =
Exceções
Ao desenvolver uma simulação, podem acontecer erros de indexação, divisões por zero, ou
outros problemas. Em alguns desses casos, sabemos que esses erros vão acontecer, mas não
há outra forma de desenvolver o programa. O seguinte bloco de código exemplifica isso:
var =
15 16 17 18
x = var(i)
end
x=
15
x=
16
x=
17
x=
18
Repare que um erro foi retornado após o programa tentar acessar o 5º elemento de um vetor
de tamanho 4.
for i = 1:6
try
x = var(i)
catch
x=0
end
end
O Matlab tenta acessar o elemento i da variável var para atribuir à variável x. Caso ele não
consiga, ele executa o bloco de código catch, que atribui o valor 0 à variável x. O resultado
deste código é:
x=
15
x=
16
x=
17
x=
18
x=
x=
Exercício
Objetivo geral
Desenvolver um programa que recebe uma lista de dados de alunos de uma escola e gera um
relatório. Os dados estarão em forma de uma tabela, onde as colunas são: Matrícula, Nome,
Idade, Curso, Turma, Turno, Situação.
Etapas
A tabela de entrada estará em forma de uma matriz do tipo cell, construir uma função que
converte a tabela cell num vetor struct com os campos correspondentes
O Matlab possui uma ferramenta para simplificar a criação de GUIs, o GUIDE. Neste curso,
vamos criar uma interface simples, com dois eixos de plot, um campo de entrada de dados,
dois botões de radio e um botão de apertar. No primeiro eixo vamos plotar um seno, e no
segundo vamos plotar um cosseno ou uma tangente, dependendo do botão de radio marcado.
A frequência da senoide será inicialmente 0, mas poderá ser alterada através do campo de
dado.
Criação da interface
Para iniciar a criação da interface, escolha a pasta que você quer que os arquivos estejam
salvos e digite na janela de comandos:
>> guide
Na janela quick start que apareceu, escolha Blank GUI e pressione OK.
Início da ferramenta GUIDE
A janela que se abre é o editor de interfaces. É aí que os botões são dispostos na janela. Para
adicionar uma componente, basta clicar no botão na parte esquerda e arrastá-lo para a parte
central, na posição desejada. Cada componenteadicionada possui atributos, que podem ser
visualizados através de um duplo clique:
Atributos do botão
Por fim, inclua um campo edit text no painel inferior esquerdo dois radiobuttons na parte
inferior do painel direito:
Interface construida
Salve o arquivo com o nome interface, uma janela com vários códigos irá aparecer. Ao digitar
na janela de comando o comando interface, a janela da interface se abrirá.
Interface
Repare que nenhuma ação é executada ao clicar nos botões ou alterar o campo de texto. Isso
acontece porque apenas a interface está criada, falta atribuir ações à cada uma das
componentes. É isso que faremos na próxima etapa.
Ao salvar a interface criada, dois arquivos são gerados pela ferramenta, um interface.fig, que é
a interface em si, e interface.m que é o código que indica a ação que cada componente gera.
Este arquivo é organizado como funções, das quais as mais importantes são:
Assim, para atribuir ações aos componentes, basta indicá-las no espaço correspondente à
componente. Após escrever o código, não esqueça de salvar o arquivo. A seguir, vamos
atribuir algumas ações às componentes:
Ação do botão
display('Botão pressionado')
salve, e execute a função. Repare que toda vez que o botão é pressionado, uma
mensagem Botão pressionado é impressa na janela de comandos.
plot(randn(1,10))
Plotando após pressionar o botão
Repare que o eixo em que o gráfico foi plotado não foi escolhido. Para escolher o eixo, é
preciso passar para a função plot um indicador da componente a ser utilizada. Todas as
componentes estão dispostas na variável handles, struct criada automaticamente pela
ferramenta GUIDE. Para esta interface, a variável handles possui os seguintes campos:
handles =
figure1: 191.0381
uipanel3: 27.0389
uipanel2: 25.0389
uipanel1: 19.0397
pushbutton1: 192.0381
radiobutton1: 34.0389
radiobutton2: 33.0389
axes2: 28.0389
edit1: 26.0389
axes1: 20.0389
output: 191.0381
Os valores atribuídos à cada campo não são muito importante, são as referências que o Matlab
criou ao gerar a interface. Assim, para escolher o eixo em que o plot será feito, basta passar o
valor handles.axes1 ou handles.axes2.
A ação de cada componente é atribuída por uma função dentro do arquivo interface.m. Sendo
funções, todas as variáveis criadas são apagadas após sua execução. Caso seja necessário
guardar valores entre as ações das componentes, pode-se atribuir à variável handles outros
campos, que guardarão os valores desejados.
Por exemplo, para criar um contador de apertos no botão, precisamos de uma variável que
guarde o número de vezes que o botão foi pressionado. Criamos um campo
chamado contador na variável handles, inicializado com 0, e atribuímos a ação de somar 1
sempre que o botão for pressionado.
handles.output = hObject;
guidata(hObject, handles);
handles.contador = handles.contador + 1;
>> interface
Isso acontece porque as funções de ação não retornam nenhum valor, ou seja, a alteração
realizada na variável handle.contador se perde após a execução da função. Para salvar as
variáveis, é necessário usar a função guidata(hObject, handles);. Assim, a
função pushbutton1_Callback ficará:
handles.contador = handles.contador + 1;
guidata(hObject, handles);
>> interface
O valor do campo de texto está armazenado na variável hObject, que como o próprio nome já
diz, é um objeto. Para atribuir ou receber valores da variável hObject, usamos respectivamente
as funções set(hObject,'<atributo>',<valor>) e get(hObject,'<atributo>'). Vimos anteriormente
que a variável handles traz a referência para todos os componentes da interface. Em
contrapartida, a variável hObject traz os atributos apenas da componente atual, que estamos
atribuindo a ação. Cada componente tem seu conjunto de atributos.
Para ver os atributos disponíveis no campo de texto, incluímos na sua função de ação
(edit1_Callback) o código get(hObject). Ao alterar o valor do campo, a seguinte mensagem é
impressa na janela de comandos:
BackgroundColor = [1 1 1]
Enable = on
FontAngle = normal
FontSize = [8]
FontUnits = points
FontWeight = normal
ForegroundColor = [0 0 0]
HorizontalAlignment = center
KeyPressFcn =
ListboxTop = [1]
Max = [1]
Min = [0]
Style = edit
TooltipString =
Units = characters
Value = [0]
BeingDeleted = off
ButtonDownFcn =
Children = []
Clipping = on
DeleteFcn =
BusyAction = queue
HandleVisibility = on
HitTest = on
Interruptible = on
Parent = [25.0402]
Selected = off
SelectionHighlight = on
Tag = edit1
Type = uicontrol
UIContextMenu = []
UserData = []
Visible = on
Repare que o atributo String recebeu o valor digitado no campo de texto. Assim, é esse o
campo que precisamos ler se quisermos receber o valor da frequência digitado pelo usuário.
Para guardar o valor digitado, criamos um campo na variável handles.
handles.f = 0;
handles.output = hObject;
guidata(hObject, handles);
handles.f = get(hObject,'String');
guidata(hObject, handles);
>> interface
Valor da variável f: 4
Valor da variável f: 5
Utilizando os radiobuttons
Cada radiobutton tem uma função de ação. O estado de um botão de ação é acessado pelo
atributo Value, que se for igual a 1 indica que o botão está marcado e se for igual a 0 indica
que o botão não está marcado. Dependendo de vários fatores, ao marcar um botão, é possível
que um botão previamente marcado seja desmarcado ou não. Assim, uma ação interessante
de ser executada quando um radiobutton for marcado é a desmarcação dos
outros radiobuttons. Ou seja, na função de ação do radiobutton1, radiobutton1_Callback,
escrevemos:
set(handles.radiobutton1,'Value',1)
set(handles.radiobutton2,'Value',0)
set(handles.radiobutton1,'Value',0)
set(handles.radiobutton2,'Value',1)
Repare que os atributos dos componentes também podem ser acessados a partir da referência
disponível na variável handles.
É interessante também guardar o radiobutton escolhido. Para isso, criamos uma variável
chamada estado, como um campo da variável handles. Esta variável terá os valores 1 ou 2,
dependendo do radiobutton escolhido. Além disso, pode ser necessário inserir um estado
inicial dos radiobuttons, evitando que todos fiquem desmarcados. Assim, para trabalhar com
os radiobuttons fazemos:
handles.estado = 1;
set(handles.radiobutton1,'Value',1)
set(handles.radiobutton2,'Value',0)
handles.output = hObject;
guidata(hObject, handles);
handles.estado = 1;
set(handles.radiobutton1,'Value',1)
set(handles.radiobutton2,'Value',0)
guidata(hObject, handles);
handles.estado = 2;
set(handles.radiobutton1,'Value',0)
set(handles.radiobutton2,'Value',1)
guidata(hObject, handles);
Repare que foi necessário converter o número para string. Ao executar a interface,
observamos o resultado esperado:
>> interface
Radiobutton selecionado: 1
Radiobutton selecionado: 2
Radiobutton selecionado: 2
Completando a interface
Para completar a interface, seguimos os passos:
% ------------------------------------------------------
handles.estado = 1;
set(handles.radiobutton1,'Value',1)
set(handles.radiobutton2,'Value',0)
handles.f = 0;
handles.t = 0:0.001:1;
plot(handles.axes1,sin(2*pi*handles.f*handles.t))
plot(handles.axes2,cos(2*pi*handles.f*handles.t))
% ------------------------------------------------------
handles.output = hObject;
guidata(hObject, handles);
- Na função radiobutton1_Callback, incluímos os códigos para o comportamento adequado:
handles.estado = 1;
set(handles.radiobutton1,'Value',1)
set(handles.radiobutton2,'Value',0)
guidata(hObject, handles);
handles.estado = 2;
set(handles.radiobutton1,'Value',0)
set(handles.radiobutton2,'Value',1)
guidata(hObject, handles);
handles.f = str2double(get(hObject,'String'));
guidata(hObject, handles);
- Por fim, na função pushbutton1_Callback, plotamos o seno com o valor atual de frequência e
selecionamos o segundo plot baseados no radiobutton escolhido:
plot(handles.axes1,sin(2*pi*handles.f*handles.t))
if handles.estado == 1
plot(handles.axes2,cos(2*pi*handles.f*handles.t))
elseif handles.estado == 2
plot(handles.axes2,tan(2*pi*handles.f*handles.t))
end
interface.zip
>> x = imread('imagem1.jpeg');
Para visualizar a imagem, é utilizada a função imshow. Uma figura pode antes ser aberta, para
evitar que a imagem seja exibida em cima de uma outra figura:
>> figure
>> imshow(x)
>> whos x
A imagem é para o Matlab uma matriz de 599x507, do tipo uint8. Sendo o valor um inteiro de
8 bits sem sinal, os valores podem ir de 0 a 255. No Matlab, valores mais próximos de 0 são de
cor escura e valores mais próximos de 1 são de cor clara.
Negativo da imagem
>> y = uint8(-1*(double(x)-255));
>> figure
>> imshow(y)
Negativo da imagem
Aumentando e reduzindo o brilho
Aumentar o brilho significa deixar a imagem mais clara. Esta operação é feita somando uma
constante à imagem:
>> z = x + 50;
>> figure
>> imshow(z)
Para aumentar o contraste, deixamos as cores claras mais claras e as cores escuras mais
escuras. Isso pode ser feito facilmente no Matlab com algumas operações matemáticas.
Primeiro, definimos o que são cores claras e o que são cores escuras, através de um limiar:
>> a = double(x)/limiar;
Por isso a conversão de x para o tipo double foi necessária, já que o tipo uint8 não permite
representar esses resultados. Após a divisão, o aumento no contraste é realizado por uma
potenciação:
>> b = a.^2;
Essa operação faz com que os valores maiores que 1 fiquem ainda maiores, e os valores
menores que 1 ainda menores. A operação é concluída ao multiplicar os valores pelo limiar, e
converter os dados para uint8 novamente:
>> c = uint8(b*limiar);
>> figure
O contraste pode ser ainda mais realçado ao utilizar potências maiores do que 2. Da mesma
forma, podemos reduzir o contraste ao utilizar operações de raiz.
Binarização
A binarização é uma forma de separar regiões de imagens. A imagem resultante será branca
nas regiões onde a intensidade da imagem original é maior que um determinado limiar e preta
nas outras regiões. Essa operação é realizada de forma muito simples no Matlab. Para
demonstrar isso, vamos usar o mesmo limiar utilizado no aumento de contraste. A binarização
é realizada a partir de um teste:
Na linha acima, primeiro testamos se x é maior ou igual ao limiar. O Matlab retorna o lógico 1
quando o teste é verdadeiro e o lógico 0 quando o teste é falso. Esses resultados são
armazenados na variável d.
Ao analisar o resultado (o imshow entende quando seu argumento é uma matriz binária),
vemos que as partes mais claras da imagem ficaram brancas, enquanto as mais escuras
ficaram pretas.
Binarização
Marcas d'água são pequenos logos incluídos nas imagens, normalmente utilizados para
informação de autoria. Vamos adicionar o logo do IFSC na imagem em escala de cinza x que
estamos utilizando até agora.
Primeiro, baixamos o logo do IFSC e salvamos na mesma pasta que estamos trabalhando, com
o nome logo.gif. Lemos o arquivo no Matlab com:
Para adicionar o logo como marca d'água, vamos transformar seus valores de forma que os
seus valores máximos (cores brancas) fiquem com um valor 1. Para isso, executamos:
Assim, o valor máximo da imagem será dividido por ele mesmo, o que resultará em 1. Os
outros valores ficarão entre 0 e 1.
Para poder multiplicar o logo pela imagem, precisamos corrigir a diferença no tamanho entre
as matrizes. Para isso, vamos criar uma nova matriz, de nome camada, do mesmo tamanho da
imagem. A matriz será composta de 1.
Assim, estamos dizendo que o logo ficará distribuído na matriz camada a partir da linha e
coluna 1:
Após isso, basta realizar a multiplicação ponto a ponto das imagens, não esquecendo as
conversões necessárias:
Como resultado, temos a imagem original com a marca do IFSC incluída na parte superior
esquerda:
Imagem com marca d'água
Suavização
Suavizar uma imagem significa reduzir sua nitidez. É realizado através do cálculo da média local
ao redor de todos os pixels da imagem. No Matlab, isso é feito com a criação de uma matriz de
média, chamada de máscara para realização de uma operação de convolução.
- Primeiro, uma matriz de média é criada. Ela deve ser quadrada, de tamanho ímpar, e a soma
de seus elementos deve resultar em 1:
mask1 =
>> sum(sum(mask1))
ans =
- O cálculo da média é efetivado com o uso da função conv2. Essa função percorre a máscara
por todos os pixels da imagem, realizando operações de multiplicação e soma.
>> size(suav1)
ans =
599 507
>> figure
Outros tipos de operadores de média podem ser utilizados, com máscaras maiores, ou mesmo
não uniformes. Para máscaras uniformes, a função ones pode ser utilizada:
mask2 =
Detecção de bordas
sobel_v =
-1 -2 -1
0 0 0
1 2 1
sobel_h =
-1 0 1
-2 0 2
-1 0 1
Pode também ser feita a soma das componentes verticais e horizontais das bordas:
>> figure
Imagem colorida
Agora vamos ler a imagem colorida, e verificar as diferenças com relação à escala de cinza:
>> a = imread('imagem2.jpeg');
>> figure
>> imshow(a)
Imagem colorida
>> whos a
Repare que, da mesma forma que a imagem em escala de cinza, a imagem colorida é
composta por valores do tipo uint8. Porém, neste caso, há uma terceira dimensão disponível. É
a partir desta nova dimensão que as características de cor são passadas. Uma imagem colorida
é composta por 3 planos de cor, cada um representando a quantidade disponível das cores
vermelho, verde ou azul. Quanto maior o valor de um elemento do plano, maior a quantidade
da cor correspondente. Com isso, temos as componentes RGB da imagem.
Vamos criar uma imagem que indica a quantidade de cada cor disponível. Para isso, vamos
separar uma figura do Matlab em 4 sub-figuras com a função subplot. Primeiro, abrimos uma
nova figura, e na primeira subfigura, exibimos a imagem colorida:
>> figure
Paleta de cores
Visando deixar a imagem da paleta de cores um pouco mais visual, vamos criar imagens
baseadas na imagem inicial. Criamos 3 matrizes, b_R, b_G, e b_B, do tamanho da imagem
inicial, inicialmente com zeros. Não esquecer que o tipo dos dados deve ser uint8.
>> figure
Com essa nova imagem, deixamos ainda mais claro como estão distribuídas as componentes
de cor.
Paleta de cores
Projeto final
Autenticar-se
Página
Discussão
Ler
Ver código-fonte
Ver histórico
Navegação
Página principal
Portal comunitário
Mudanças recentes
Ajuda
Ensino
TELE
RAC
Cultura Geral
Pedagógico
Pesquisa
TELE
RAC
Cultura Geral
Extensão
Projetos
Serviços
Horários
Calendário
CTIC
Biblioteca
Legislação
Geração de livros
Ramais
Imprimir/exportar
Criar um livro
Ferramentas
Páginas afluentes
Alterações relacionadas
Páginas especiais
Link permanente
Esta página foi modificada pela última vez às 19h22min de 16 de outubro de 2015.
Política de privacidade
Alerta de Conteúdo