Escolar Documentos
Profissional Documentos
Cultura Documentos
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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 1/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Índice
Curso Matlab aplicado ao processamento de imagens - Aula 1
Indexação de matrizes
Indexação simples
Indexação múltipla
Uso do ":"
O comando end
Índice versus Subscrito
Classes de dados
Char
Concatenação de caracteres e números
Cell
O problema
A classe cell
Structs
Funções
Argumento e retorno simples
Argumento e retorno múltiplo
Variáveis locais e globais
Funções inline
Exceções
Exercício
Curso Matlab aplicado ao processamento de imagens - Aula 2
Criação da interface
Atribuir uma ação às componentes
Ação do botão
Plotando ao pressionar o botão
Referenciando uma componente específica
Guardando valores entre componentes
Capturando o valor do campo de texto
Utilizando os radiobuttons
Completando a interface
Curso Matlab aplicado ao processamento de imagens - Aula 3
Imagem em escala de cinza
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 2/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Negativo da imagem
Aumentando e reduzindo o brilho
Aumentando e reduzindo o contraste
Binarização
Adicionando uma marca d'água
Suavização
Detecção de bordas
Imagem colorida
Criando uma imagem da paleta de cores
Paleta de cores modificada
Projeto final
Indexação simples
Uma das maiores barreiras do usuário do Matlab é a compreensão da indexação de variáveis. A indexação é realizada com parênteses e o número da linha/coluna/etc que se
deseja acessar. Para entender isso, vamos criar 3 variáveis, um vetor linha, um coluna e uma matriz:
>> lin(1)
ans =
>> col(1)
ans =
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 3/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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:
ans =
2 4
6 8
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 4/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 5/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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 =
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 =
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 6/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
6
ans =
1 5
2 6
3 7
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:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 7/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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!
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 (http://www.mathworks.com/help/matlab/ref/nu
m2str.html):
var5 =
a35
Cell
O problema
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 8/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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'
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 9/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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'
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 10/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Name Size Bytes Class Attributes
>> 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 (http://www.mathworks.com/help/matlab/ref/struct.html):
>> 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: []
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 11/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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 =
Marca: 'Volkswagen'
Modelo: 'Fusca'
s2 =
Marca: 'Volkswagen'
Modelo: 'Fusca'
Ano: 1962
s2 =
Marca
Modelo
Ano
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 12/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Funções
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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 13/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
soma = x1 + x2;
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 =
subt =
-1
mult =
divs =
0.5000
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 14/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Funções inline
Uma forma rápida de criar funções simplificadas é através do comando inline (http://www.mathworks.com/help/matlab/ref/inline.html):
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)
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 15/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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.
Para casos como esse há no Matlab o tratamento de exceção, através dos comandos try e catch. Digamos no exemplo acima, a aplicação aceite que ao atingir o final da
variável, atribuamos o valor 0 à variável x. Com o tratamento de exceção, isto seria resolvido da seguinte forma:
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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 16/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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
A geração do relatório deverá usar os dados na forma de struct
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 17/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
O Matlab possui uma ferramenta para simplificar a criação de GUIs, o GUIDE (http://www.mathworks.com/help/matlab/gui-building-basics.html). 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.
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 18/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 19/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Atributos do botão
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 20/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Painéis
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 21/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Axes
Por fim, inclua um campo edit text no painel inferior esquerdo dois radiobuttons na parte inferior do painel direito:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 22/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Interface construida
É possível alterar as informações escritas na interface, clicando duas vezes na componente e alterando o campo Title, no caso dos painéis, ou String para os demais. A
interface concluída pode ser vista abaixo:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 23/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Interface concluída
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á.
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 24/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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.
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:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 25/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Ação do botão
Inclua na função pushbutton1_Callback o código:
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))
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 26/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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.
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.
Para criar o campo e inicializá-lo com zero, inserimos um código à função interface_OpeningFcn, que ficará assim:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 27/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
handles.output = hObject;
guidata(hObject, handles);
O incremento do contador, e a impressão da mensagem com o número de vezes que o botão foi pressionado são incluídos na função pushbutton1_Callback:
handles.contador = handles.contador + 1;
Porém, ao executar a interface e pressionar o botão, observamos que aparece sempre a mesma mensagem:
>> 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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 28/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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]
CData = []
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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 29/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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);
Adicionamos a ação de guardar o valor digitado no campo de texto, na função edit1_Callback. Não esquecer de salvar a alteração na variável com a função
guidata(hObject, handles);:
handles.f = get(hObject,'String');
guidata(hObject, handles);
Por fim, configuramos no botão a ação de mostrar na janela de comandos o valor da variável handles.f:
>> interface
Valor da variável f: 4
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 30/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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:
- Adicionamos na função interface_OpeningFcn a criação da variável estado e a rotina de inserção do seu estado inicial:
handles.estado = 1;
set(handles.radiobutton1,'Value',1)
set(handles.radiobutton2,'Value',0)
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 31/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
handles.output = hObject;
guidata(hObject, handles);
- Dizemos que, ao selecionar um radiobutton o outro deve ser desmarcado, e guardamos o estado dos botões:
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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 32/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Radiobutton selecionado: 2
Radiobutton selecionado: 2
Completando a interface
Para completar a interface, seguimos os passos:
- Na função interface_OpeningFcn, inserimos um estado inicial para os botões, geramos um estado inicial para a frequência dos sinais, geramos o eixo do tempo no qual os
sinais estarão definidos e fazemos os plots com os valores padrão:
% ------------------------------------------------------
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);
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 33/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 34/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
plot(handles.axes2,tan(2*pi*handles.f*handles.t))
end
interface.zip
Inicialmente, salve as duas imagens abaixo no diretório de trabalho, e altere o diretório do Matlab para esta pasta. Para facilitar o trabalho, salve as variáveis como
imagem1.jpeg e imagem2.jpeg.
>> x = imread('imagem1.jpeg');
Para visualizar a imagem, é utilizada a função imshow (http://www.mathworks.com/help/images/ref/imshow.html). Uma figura pode antes ser aberta, para evitar que a
imagem seja exibida em cima de uma outra figura:
>> figure
>> imshow(x)
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 35/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
>> 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.
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 36/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Negativo da imagem
Para tirar o negativo da imagem, precisamos transformar valores próximos de 0 em valores próximos de 255, e vice-versa. Uma forma de fazer isso é subtrair 255 da imagem,
e depois multiplicar por -1. Neste caso, porém, precisaremos realizar uma mudança no tipo do dado, pois a variável é inteira e sem sinal:
>> y = uint8(-1*(double(x)-255));
>> figure
>> imshow(y)
Negativo da imagem
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 37/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
>> z = x + 50;
>> figure
>> imshow(z)
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 38/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Esta variável indica que todos os valores com intensidade acima de 180 serão realçados enquanto todos abaixo de 180 serão atenuados. Com o limiar definido, fazemos uma
operação de divisão:
>> 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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 39/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Aumento de contraste
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:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 40/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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
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:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 41/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 42/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 43/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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 =
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 44/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
0.1111 0.1111 0.1111
>> 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
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 45/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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 =
mask3 =
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 46/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
0.1333 0.2000 0.1333
Detecção de bordas
A detecção de bordas em imagens é feita de forma semelhante à suavização, porém uma máscara diferente é utilizada. Neste curso vamos usar uma máscara específica, de
Sobel (http://pt.wikipedia.org/wiki/Filtro_Sobel), mas existem muitas outras que podem ser utilizadas, com vantagens e desvantagens específicas. A máscara de Sobel é
definida para bordas verticais e horizontais, respectivamente:
sobel_v =
-1 -2 -1
0 0 0
1 2 1
sobel_h =
-1 0 1
-2 0 2
-1 0 1
Ao aplicar os operadores na imagem, usando a função conv2, temos como resultado as imagens abaixo:
>> figure
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 47/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Pode também ser feita a soma das componentes verticais e horizontais das bordas:
>> figure
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 48/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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)
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 49/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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.
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 50/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
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 (http://ww
w.mathworks.com/help/matlab/ref/subplot.html). Primeiro, abrimos uma nova figura, e na primeira subfigura, exibimos a imagem colorida:
>> figure
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 51/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Paleta de cores
Após isso, atribuímos o primeiro plano da imagem original ao primeiro plano da imagem b_R. O segundo plano da imagem original é atribuído ao segundo plano da imagem
b_G, e o terceiro plano ao terceiro plano da imagem b_B:
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 52/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
>> figure
Com essa nova imagem, deixamos ainda mais claro como estão distribuídas as componentes de cor.
Paleta de cores
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 53/54
27/08/2021 Curso Matlab aplicado ao processamento de imagens - MediaWiki do Campus São José
Projeto final
O projeto consiste na criacao de uma ferramenta de processamento de imagens. O usuario ira entrar com o nome do arquivo num campo de texto, e clicar num botao para a
realizacao da leitura da imagem. A imagem sera lida pelo sistema e exibida no eixo da imagem original. Na segunda area da interface, varias operacoes poderao ser
selecionadas, e os resultados serao exibidos no eixo da imagem processada.
Disponível em "https://wiki.sj.ifsc.edu.br/index.php?title=Curso_Matlab_aplicado_ao_processamento_de_imagens&oldid=94970"
Esta página foi modificada pela última vez em 16 de outubro de 2015, às 16h22min
https://wiki.sj.ifsc.edu.br/index.php/Curso_Matlab_aplicado_ao_processamento_de_imagens 54/54