TCC_William Strafacce Soares_2013_v3
59
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ COORDENAÇÃO DE ANÁLISE E DESENVOLVIMENTO DE SISTEMAS CURSO SUPERIOR DE TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS WILLIAM STRAFACCE SOARES TÉCNICA PARA SEGMENTAÇÃO AUTOMÁTICA DE IMAGENS DIGITAIS TRABALHO DE CONCLUSÃO DE CURSO CORNÉLIO PROCÓPIO 2013
-
Upload
william-soares -
Category
Documents
-
view
14 -
download
0
Transcript of TCC_William Strafacce Soares_2013_v3
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ
COORDENAÇÃO DE ANÁLISE E DESENVOLVIMENTO DE SISTEMAS
CURSO SUPERIOR DE TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS
WILLIAM STRAFACCE SOARES
TÉCNICA PARA SEGMENTAÇÃO AUTOMÁTICA DE IMAGENS
DIGITAIS
TRABALHO DE CONCLUSÃO DE CURSO
CORNÉLIO PROCÓPIO
2013
WILLIAM STRAFACCE SOARES
TÉCNICA PARA SEGMENTAÇÃO AUTOMÁTICA DE IMAGENS
DIGITAIS
Proposta apresentada à disciplina de Trabalho de Diplomação, do Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas, da Universidade Tecnológica Federal do Paraná – UTFPR, como requisito parcial para obtenção do título de Tecnólogo.
Orientador: Prof. Dr. Fabricio Martins Lopes
Co-Orientador: Prof. Dr. Pedro Henrique Bugatti
CORNÉLIO PROCÓPIO
2013
Dedicado à Sra. Maria Helena Strafacce, Sr. Luis
Antonio Strafacce e Sr. Moisés Ventura Soares,
por todo apoio, conselhos e exemplos de vida.
Ao Prof. Dr. Fabrício Martins Lopes e Prof. Dr.
Pedro Henrique Bugatti pela paciência, ajuda e
orientação na área acadêmica e pessoal.
AGRADECIMENTOS
Gostaria de demonstrar meus agradecimentos a todas as pessoas que
fizeram parte de meu crescimento pessoal e intelectual. Certamente não serei capaz
de contemplar a todos que fizeram parte desta conquista e deixo aqui minhas
desculpas aqueles que não foram citados.
Reverencio os Professores Doutores Fabricio Martins Lopes e Pedro
Henrique Bugatti, por toda sua carreira acadêmica e profissional. Gostaria de deixar
meus agradecimentos pela dedicação incondicional nesta orientação e em toda
orientação no Projeto de Pesquisa desenvolvido entre 2011 e 2012.
Agradeço os professores da presente banca pelo tempo reservado ao
estudo desta monografia e contribuições presentes em seus comentários.
Deixo meus agradecimentos a Universidade Técnologica Federal do Paraná
e a todos os seus servidores, pelo carinho e dedicação na realização de seus
trabalhos.
Gostaria de agradecer a toda a minha família que me ajudou em todos os
momentos para que eu fosse capaz de realizar esta conquista.
.
“O medo faz parte da vida da gente. Algumas
pessoas não sabem como enfrentá-lo, outras -
acho que estou entre elas - aprendem a
conviver com ele e o encaram não como uma
coisa negativa, mas como um sentimento de
autopreservação.” (SENNA, A)
LISTA DE FIGURAS
Figura 1 - Relações de vizinhanças mais comuns .................................................... 17
Figura 2 - Fluxograma tradicional de um sistema de PID .......................................... 18
Figura 3 - Linhas divisórias, mínimos e bacias de captação em relevo topográfico .. 23
Figura 4 - Interface do software SegmentIt ............................................................... 25
Figura 5 – Folha da classe Quercus Ilex ................................................................... 34
Figura 6 - Resultado da aplicação do Algoritmo 5 na Figura 5. ................................. 35
Figura 7 - Imagem de marcador gerada via interface do SegmentIt ......................... 36
Figura 8 – Folha de classe não relacionada em índice ............................................. 38
Figura 9 – Folha da classe Broussonetia papyrifera ................................................. 38
Figura 10 - Resultado da aplicação do Algoritmo 8 na Figura 5 ................................ 41
Figura 11 - Resultado da aplicação do marcador (Figura 10) na Figura 6 ................ 42
Figura 12 - Resultado da aplicação do Algoritmo 10 na Figura 10 ............................ 44
Figura 13 - Resultado do processo de segmentação aplicado na Figura 5 ............... 45
Figura 14 - Resultado da aplicação do marcador tipo cruz sobre uma amostra da
classe de folha Syringa vulgaris ................................................................................ 47
Figura 15 - Resultado da aplicação do marcador tipo tridente sobre uma amostra da
classe de folha Syringa vulgaris ................................................................................ 47
Figura 16 - Resultado da aplicação do marcador tipo circulo, com 4px de diâmetro,
sobre uma amostra da classe de folha Syringa vulgaris ........................................... 48
Figura 17 - Resultado da aplicação do marcador tipo cruz sobre uma amostra da
classe de folha Acer campestre ................................................................................ 48
Figura 18 - Resultado da aplicação do marcador tipo tridente sobre uma amostra da
classe de folha Acer campestre ................................................................................ 49
Figura 19 - Resultado da aplicação do marcador tipo circulo, com 4px de diâmetro,
sobre uma amostra da classe de folha Acer campestre ............................................ 49
Figura 20 - Resultado do processo de segmentação automático com marcador do
tipo cruz. .................................................................................................................... 50
Figura 21 - Resultado do processo de segmentação automático com marcador do
tipo tridente. ............................................................................................................... 51
Figura 22 - Resultado do processo de segmentação automático com marcador do
tipo circulo. ................................................................................................................ 52
Figura 23 – Resultado comparativo da eficiência de cada tipo de marcador, ao ser
aplicado no banco de imagens .................................................................................. 53
LISTA DE SIGLAS
UTFPR Universidade Tecnológica Federal do Paraná
USP Universidade de São Paulo
PID Processamento de imagens digitais
DIP Digital Image Processing
API Application programming interface
JAI Java Advanced Image
SUMÁRIO
1. INTRODUÇÃO .................................................................................................... 9 2. JUSTIFICATIVA E MOTIVAÇÃO ...................................................................... 11 3. ÁREA DE PESQUISA QUE O TRABALHO CONTEMPLA ............................... 12 4. OBJETIVOS ...................................................................................................... 13 5. ESCOPO DO TRABALHO ................................................................................ 14 6. TECNOLOGIAS UTILIZADAS .......................................................................... 15 7. REVISÃO BIBLIOGRÁFICA ............................................................................. 16
7.1 SEGMENTAÇÃO .............................................................................................. 20
7.2 SEGMENTAÇÃO POR WATERSHEDS ........................................................... 22
8 MÉTODOLOGIA DE DESENVOLVIMENTO..................................................... 25
9. RESULTADOS E DISCUSSÕES ...................................................................... 47 10. CONCLUSÕES ................................................................................................. 54 11 REFERÊNCIAS ................................................................................................ 55
7
Resumo
SOARES, W. S.; LOPES, F. M.; BUGATTI, P.H. Técnica para segmentação automática de imagens digitais. Monografia de trabalho de conclusão de curso. Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas. Universidade Tecnológica Federal do Paraná, Campus Cornélio Procópio, 2013. A crescente evolução tecnológica nas diversas áreas de conhecimento, como visão computacional e imageamento médico, vem gerando um grande volume de dados que necessitam de um processamento eficaz e com baixo custo computacional. Com isso, surge à necessidade da criação de técnicas que possibilitem a interpretação e classificação dos dados de forma ágil, para que o processo de entendimento aconteça com fluidez e consistência nos resultados. Dentre as diversas áreas de processamento de dados, como mapeamento genético e manipulação de dados digitais, o processamento de imagens digitais (PID) vem ganhando amplo espaço de aplicação. Segundo Gonzalesianos um dos principais desafios presentes no PID é a criação de um processo de segmentação automático, que apresente qualidades como consistência, usabilidade e dinamismo. O processo de segmentação, por sua vez, acaba por determinar o sucesso ou insucesso de todo um sistema PID. Visando atacar este problema foi desenvolvido ao longo deste trabalho uma metodologia de segmentação automática de imagens, que utiliza técnicas desenvolvidas na ferramenta de segmentação SegmentIt. Ao aplicar a metodologia proposta no banco de imagens, foi percebido que a técnica obteve melhores resultados em imagens de folhas com formato arredondado. Ao aplicar-se sob imagens de folhas com formato estrelado algumas dificuldades foram encontradas, como evitar que o marcador se sobrepusesse a região de fundo da imagem. Palavras-chave: PID; Watershed; SegmentIt; Segmentação de imagens.
8
Abstract
SOARES, W. S.; LOPES, F. M.; BUGATTI, PH. Technique for automatic segmentation of digital images. Monograph of completion of course work. Degree in Technology in Analysis and Systems Development. Federal Technological University of Paraná, Campus Cornélio Procópio, Paraná, Brazil, 2013. The growing technological developments in several areas of knowledge, such as computer vision and medical imaging, has generated a great deal of data that require effective processing and low computational cost. With that comes the need to develop techniques that allow the interpretation and classification of data in a fast, so that the process of understanding happens with fluidity and consistency of results. Among the various areas of data processing, such as genetic mapping and manipulation of digital data, the digital image processing (PID) has gained large application space. According Gonzalesianos present a major challenge in PID is the creation of an automatic segmentation process, presenting qualities such as consistency, usability and dynamism. The segmentation process, in turn, ultimately determines the success or failure of an entire PID system. Aiming to tackle this problem was developed in this work a methodology for the automatic segmentation of images, which uses techniques developed in segmentation tool SegmentIt. By applying the proposed methodology on the image data base, it was realized that the technique achieved better results in images of leaves with rounded shape. When applying under images of leaves shaped starring some difficulties were encountered, how to prevent the marker region straddling the background image. Key-words: PID; Watershed; SegmentIt; Image segmentation.
9
1. INTRODUÇÃO
O processamento e a análise de imagens são campos da computação que
vêm crescendo continuamente e ocupando espaços importantes nos mais diversos
meios, com destaque para visão computacional e imageamento médico [1]. Ao
processar uma imagem, há vários objetivos que podem ser atingidos, como, por
exemplo, melhorar a qualidade de uma imagem ruidosa [2].
Através de uma imagem pode-se mapear diversas características que
podem indicar a saúde ou defeito de um material analisado, apontar diferenças entre
eles, reconhecer características específicas e identifica-lo, selecionar e agrupar
classes de objetos, dentre outras possibilidades. Podem-se considerar materiais
como sendo células, folhas, rostos de pessoas, expressões faciais [3], entre outras.
Dentre as características é possível considerar texturas, dimensões, forma,
luminosidade, reflexão, entre outras.
O processamento de imagens digitais (PID) é a área responsável por reunir
estas características, melhorar a qualidade da imagem, determinar áreas de
interesse na imagem e armazenar os resultados [4]. No processamento de uma
imagem digital são realizados diversos passos fundamentais que determinam a
qualidade dos resultados obtidos. Estes passos podem ser identificados no
fluxograma tradicional de um sistema de PID, apresentado por Gonzales [4]. A
segmentação é o processo de seleção de áreas de interesse dentro de uma imagem
complexa. Através deste processo pode-se selecionar exatamente a parte da
imagem que deverá ser analisada e descartar o restante desta, economizando assim
custo computacional e tempo.
Segundo Peccini e d’Ornellas [2], as 4 técnicas primitivas para realização de
segmentação de imagens são: Limiarização (Threshold), Detecção de bordas,
Crescimento de regiões e Contornos Ativos. Estas técnicas serão detalhadas na
seção 7.
Porém alcançar um processo de segmentação que seja robusto, altamente
reutilizável, com baixo custo operacional, dinâmico e automatizado é um dos
principais desafios encontrado na área de PID atualmente.
10
Diante desse contexto, a proposta deste trabalho está em atacar este
problema e desenvolver um processo de segmentação automática, inicialmente a
ser aplicado em imagens biológicas de folhas.
11
2. JUSTIFICATIVA E MOTIVAÇÃO
Com o crescente aumento no cenário da tecnologia da informação se faz
necessária a criação de processos informatizados nas mais diversas áreas.
Hoje é possível notar que a informática está introduzida nos mais diversos
meios, variando desde o controle de processos até auxilio em áreas da medicina,
como, por exemplo, a realização de cirurgias remotamente.
Dentre as diversas áreas, onde existe o envolvimento de ferramentas
informatizadas no auxilio de processos humanos, o PID aparece como dos principais
desafios a serem realizados.
É notado que existe um grande volume de dados a serem processados,
onde, muitos desses dados, são imagens analógicas e digitais. Esta demanda de
imagens armazenada cria a necessidade da criação de processos capazes de
interpretar imagens e converter em dados que possam ser processados e
analisados, gerando assim um banco de dados a ser reaproveitado em diversas
áreas.
Dentro do PID, como será demonstrado na seção 7, logo após o processo
de pré-processamento, encontra-se o processo de segmentação, segundo Gonzales
[4]. Este processo, como já citado anteriormente, é o que pode garantir o sucesso ou
falha dos processos posteriores. Porém, este é o processo que mais necessita de
interferência humana, uma vez que é necessário estabelecer qual a área de
interesse dentro de uma macro imagem, o que pode tornar o processo lento devido
ao grande volume de informações a serem processadas.
Esta monografia prevê a criação de um protótipo de método capaz de
autodefinir regiões de interesse através de parâmetros pré-estabelecidos.
Com isso pretende-se alcançar maior agilidade no processamento dos
dados, entregando ao processo seguinte um mapa da imagem original que defina
onde este processo, por exemplo, de reconhecimento de padrões, deve procurar
informações sobre o tipo de imagem a ser analisada.
A próxima seção aponta a área de pesquisa aplicada a este trabalho.
12
3. ÁREA DE PESQUISA QUE O TRABALHO CONTEMPLA
Esta monografia está relacionada com o projeto de pesquisa “Métodos e
técnicas para exploração e análise de bioimagens” [5] e contempla a área de
inteligência computacional.
O projeto proposto por Lopes [5] tem como principal objetivo atacar o
problema do processamento de grandes volumes de dados de multimídias
distribuídos, visando a área de imageamento digital de imagens biológicas.
Em uma visão geral, Lopes [5] propõe em sua pesquisa os seguintes
objetivos gerais:
Desenvolver métodos e técnicas inovadoras para a análise de
bioimagens;
Promover integração da equipe envolvida e reaproveitamento dos
conhecimentos adquiridos;
Introduzir e formar profissionais na área de processamento de imagens
digitais e reconhecimento de padrões.
E como objetivos mais específicos:
Desenvolver técnicas de visualização que permitam cruzar diversos
dados complementares de maneira intuitiva;
Desenvolver técnicas que capaz de segmentar automaticamente um
grande volume de imagens, sem a necessidade de interação dos usuários;
Contribuir para evolução das técnicas já existentes e problemas vigentes,
promovendo mais interação com empresas e outros grupos de pesquisa;
Contribuir para a nucleação de um grupo de pesquisa na UTFPR-CP.
Colaborar para a formação acadêmica de recursos humanos na área de
análise de imagens e reconhecimento de padrões.
Dentre os principais objetivos específicos apresentados, esta monografia
visa criar um processo de segmentação interativo e automático, com mínima
interferência humana no processo.
Sendo assim, na próxima seção são apresentados os objetivos previstos por
esta monografia.
13
4. OBJETIVOS
Os objetivos gerais desta monografia são:
Introduzir o estudo de processamento de imagens, complementando
e aplicando os conhecimentos adquiridos, na graduação.
Contribuir para a área de análise de imagens com um protótipo de
processo para segmentação automática de imagens.
Os objetivos específicos são:
Utilizar os módulos de pré-processamento e segmentação
implementados por Klava [6] na ferramenta SegmentIt para investigar,
desenvolver e validar um processo de segmentação automático,
capaz de segmentar um grande volume de imagens, com menor
custo computacional e sem a interferência humana no processo.
Contribuir para o projeto desenvolvido por Klava [6], adicionando as
funcionalidades de conversão automática de RGB para escala em
níveis de cinza, realce automático das bordas da figura e
segmentação automática de um banco de imagem no software
SegmentIt.
Contribuir com o projeto proposto por Lopes [5], introduzindo o estudo
em processamento de imagens voltado para a segmentação de
imagens.
Adquirir conhecimento e contribuir para a solução de um dos grandes
problemas encontrados na área de segmentação de imagens digitais.
14
5. ESCOPO DO TRABALHO
Este trabalho visa o desenvolvimento de uma técnica de automação para
aplicação de segmentação, via algoritmo de watersheds, em imagens biológicas de
folhas. Para isto foram utilizadas as técnicas desenvolvidas por Klava [6], em seu
trabalho de mestrado, e reunidas em uma ferramenta denominada SegmentIt.
Através dos métodos implementados por Klava [6] esta ferramenta é capaz de
segmentar imagens originadas nos mais diversos meios, porém é necessário que
haja uma interação humana, via interface, para que se obter os parâmetros que
determinam as bacias de watersheds, que será detalhada na sessão 7.2. Com isto o
processo de segmentação acaba sendo cadenciado quando se trata do
processamento de um grande volume de imagens.
Discute-se, através deste, abordagens para como complementar esta
ferramenta adicionando algoritmos capazes de estabelecer tais parâmetros e/ou
gerar padrões, descartando a interação humana no processo, para que se possa
aplicar os métodos implementados por Klava [6] e obter imagens segmentadas.
Para que isto fosse possível foi necessário, para o processo de aquisição de
imagens, a obtenção e utilização de um banco de dados biológico denominado Plant
Identification, disponibilizado gratuitamente para fins acadêmicos pela organização
ImageClef [7]. Atualmente este banco de imagens possui um total de 3962 imagens
de folhas distribuídas em 65 classes, com, onde foi possível avaliar as técnicas
desenvolvidas e obter um percentual de acerto total e individual em cada classe.
Na próxima seção serão abordadas as tecnologias utilizadas, assim como
particularidades do SegmentIt [6].
15
6. TECNOLOGIAS UTILIZADAS
Optou-se por utilizar linguagem de programação orientada a objetos devido
à modularidade e dinâmica que esta propõe ao desenvolvedor. Todo o processo foi
desenvolvido em linguagem JAVA que utiliza o paradigma de orientação a objetos e
fornece suporte a manipulação de imagens através de sua API (Application
Programming Interface) denominada JAI (Java Advanced Image) [8].
Optou-se, também, por utilizar o software SegmentIt [6] que é uma
ferramenta interativa para segmentação de imagens digitais, possibilitando que o
foco desta proposta seja o processo de automatização da segmentação. O
SegmentIt [6] é uma ferramenta desenvolvida em plataforma JAVA [8] em ambiente
Eclipse [9] e implementa módulos de segmentação por watersheds via marcadores,
capazes de definir parâmetros para a criação das bacias de watersheds, conforme
citado na sessão 5.
Os métodos desenvolvidos nesta proposta foram implementados utilizando
ambiente NetBeans [10], que proporciona ao desenvolvedor utilizar tanto os
métodos definidos na linguagem nativa JAVA como nas APIs adicionadas de
maneira simples, intuitiva e objetiva. Como API foram adicionadas as bibliotecas JAI
e JavaFX 2 que oferecem objetos para tratamento de imagens e produção de
gráficos em geral.
16
7. REVISÃO BIBLIOGRÁFICA
Segundo Russ [1], as operações de processamento de imagens têm como
objetivos básicos melhorar a aparência visual da imagem para a visão humana e/ou
preparar a imagem para a análise e mensuração de características e estruturas
presentes.
O interesse em métodos de processamento de imagens digitais decorre de
duas áreas principais de aplicação: melhoria de informação visual para a
interpretação humana e o processamento de dados de cena para percepção
automática através de máquinas [4].
O termo imagem refere-se a uma função de intensidade luminosa
bidimensional, denotada por f(x, y), em que o valor ou amplitude de f nas
coordenadas espaciais (x, y) dá a intensidade (brilho) da imagem naquele ponto [4].
Uma imagem digital é representada por uma função f(x, y), discretizada tanto
em coordenadas espaciais quanto em brilho. Uma imagem digital pode ser
considerada como sendo uma matriz cujos índices de linhas e colunas identificam
um ponto na imagem, e o correspondente valor do elemento da matriz identifica o
nível de intensidade naquele ponto. Os elementos dessa matriz digital são
chamados de elementos da imagem, elementos da figura, “pixels” ou “pels”, estes
dois últimos, abreviações de “pictures elements” [4].
O processamento digital de imagens atua sobre imagens digitais. Dessa
forma, existe a necessidade de converter um campo de imagem contínuo para uma
imagem digital equivalente [11]. Essa conversão ocorre através do mapeamento da
imagem em uma matriz de pixels (picture elements) [2], onde um pixel pode ser
considerado uma estrutura de dados composto por uma coordenada (x, y) e um
modelo de cor. Dentre os principais modelos de cor utilizados atualmente estão o
RGB (Red, Green, Blue), o CMY (Cyan, Magenta, Yellow) e o HSI (Hue, Saturation,
Intensity) [1].
17
Além do modelo de cor, o pixel possui outras propriedades determinantes no
processamento e análise da imagem: as relações de vizinhança e a conectividade
[2].
Vizinhos de um pixel – a partir de um pixel, considerando que este apresenta
a forma de um quadrado, de coordenada (x, y), pode-se afirmar a existência de 4
vizinhos horizontais e verticais e 4 vizinhos diagonais, onde cada pixel encontra-se a
uma unidade de distancia de (x, y), com as respectivas coordenadas:
(x+1, y), (x-1, y), (x, y+1), (x, y-1)
(x+1, y+1), (x+1, y-1), (x-1, y+1), (x-1, y-1)
Ao primeiro conjunto de pixels dá-se o nome de vizinhança-de-4 de P, e a
união do primeiro conjunto com o segundo dá-se o nome de vizinhança-de-8 de P,
onde alguns dos pixels do conjunto podem não existir uma vez que o pixel de
referencia exista próximo às bordas da imagem. Uma outra abordagem, é
considerando que cada pixel apresente a forma de um hexágono, onde este acaba
por possuir 6 vizinhos.
A Figura 1 exemplifica as relações de vizinhanças mais comuns:
Conectividade – para se estabelecer se dois pixels estão conectados, é
preciso determinar se eles são, de alguma forma, adjacentes (digamos, se são
Figura 1 - Relações de vizinhanças mais comuns. Fonte: [2].
18
vizinhos–de-4) e se seus níveis de cinza satisfazem certo critério de similaridade
(digamos, se eles são iguais) [4].
A conectividade está condicionada pela relação de vizinhança, pois para que
dois pixels sejam conexos deve haver uma sequencia de pixels que os liga, de forma
que dois pixels consecutivos desse caminho tenham características comuns e sejam
vizinhos [12]. Estabelecendo-se uma relação de vizinhança e conectividade entre
dois pixels, pode-se afirmar que estes fazem parte de uma mesma região de pixels
dentro de uma imagem digital.
Relações de vizinhança e conectividade são os critérios básicos para a
formação de regiões no processo de segmentação [13].
Segundo Gonzales [4], o processamento de imagens digitais pode ser divido
nos seguintes passos: aquisição, pré-processamento, segmentação, representação
e descrição, reconhecimento e interpretação. A Figura 2 ilustra os passos
fundamentais para o processamento de imagens digitais descritos:
Figura 2 - Fluxograma tradicional de um sistema de PID. Fonte: [4].
Aquisição da imagem – Para adquirir uma imagem é necessário um sensor
para o imageamento e um processamento capaz de transformar o sinal produzido
pelo sensor eu um arquivo digital.
19
Pré-processamento – Pré-processar uma imagem significa dizer que a
imagem obtida será melhorada para aumentar as chances de sucesso nos
processos seguintes. Essa melhora é obtida submetendo a imagem a processos de
filtragem, realçamento de bordas, conversão para níveis de cinza, entre outros.
Segmentação – Por definição é a ação de dividir uma imagem em varias
partes ou objetos constituintes. A segmentação automática é uma das tarefas mais
difíceis no processamento de imagens digitais. Um processo de segmentação
robusto auxilia substancialmente uma solução bem sucedida. Uma vez que se este
processo apresentar falhas, a solução pode ser totalmente comprometida. A saída
da etapa de segmentação é constituída tipicamente por pixels (“raw pixel data”),
correspondendo tanto à fronteira de uma região como a todos os pontos da mesma
[4].
Representação e descrição – A partir da segmentação obtém-se dados em
forma de pixels, que correspondem tanto a fronteira de uma determinada região
quanto a todos os pontos da mesma. É necessário então definir a melhor maneira de
representa-los. Existem duas maneiras de representação de dados:
Por fronteira: adequada quando o interesse na imagem se concentra nas
características da forma externa;
Por região: adequada quando o interesse na imagem se encontra em
propriedades internas.
A partir dai devem ser desenvolvidos métodos que melhor descrevam as
características encontradas nesta imagem. O processo de descrição tem como foco
extrair informações destes dados de maneira que se possa quantizar as informações
de interesse ou classificar cada imagem em uma classe de objetos.
Reconhecimento – é a etapa que atribuí um rotulo de identificação para cada
imagem segmentada, onde este rótulo tem por função identificar as características
daquela imagem e armazena-las para uma posterior comparação ou definição de
classe para imagens com características semelhantes.
Um dos domínios de maior relevância do processamento de imagens é a
morfologia matemática [14], que possibilita o processamento e a análise de imagens
20
nas mais diversas áreas, tais como geociências, microscopia, biologia e
imageamento médico [2], entre outras. Basicamente, pode-se dividir a morfologia
matemática em dois tipos distintos: a morfologia binária, que trata imagens binárias;
e a morfologia cinzenta, que analisa imagens em níveis de cinza [12].
7.1 Segmentação
Nesta subseção a segmentação é apresentada com mais detalhes, uma vez
que representa o foco deste trabalho. Como mencionado na seção anterior, a
segmentação de uma imagem consiste em realçar as áreas de interesse e descartar
as demais, ou seja, dividi-la em porções, de forma que a análise dos componentes
seja facilitada [14].
Em imagens monocromáticas geralmente são aplicados algoritmos que se
baseiam em detecção através das propriedades básicas dos valores de níveis de
cinza – descontinuidade e similaridade. O principio básico de descontinuidade
aborda o particionamento de uma imagem através de mudanças bruscas nos níveis
de cinza, onde o principal interesse é a detecção de pontos isolados e detecção de
linhas e bordas. Já o princípio básico de similaridade baseia-se em limiarização,
crescimento de regiões, e divisão e fusão de regiões.
Conforme citado na seção de Introdução, Peccini e d’Ornellas [2] definem 4
técnicas primitivas para realização de segmentação de imagens, são elas:
A limiarização (threshold) – consiste basicamente em definir um limiar de
referência e binarizar uma imagem de maneira que todos os valores de níveis de
cinza que se encontrarem a baixo deste valor é considerado 0 e todos os valores
acima, considerados 1 (ou 255) [15].
O threshold é efetivo quando os níveis de intensidade do objeto a ser
segmentado concentram-se fora dos níveis de intensidade do plano de fundo [2].
Imagens com uma borda não definida ou borrada pode ocasionar erros nos
algoritmos de threshold pois estes analisam apenas informação local, porém são
rápidos e apresentam um baixo custo computacional.
21
Detecção de bordas – neste tipo de abordagem o meio mais utilizado para
detecção de descontinuidades é a aplicação de filtros.
Um filtro ocasiona a transformação da imagem pixel a pixel, levando em
consideração não somente o valor do pixel corrente, mas também os valores de
seus pixels vizinhos [2]. Os filtros mais utilizados, segundo Facon [12], geralmente
são os filtros de Sobel 1 e 2, Prewitt e Laplace.
Porém a operação de filtragem não realiza a detecção de descontinuidades
sozinha, é necessária a aplicação de um valor de limiar onde uma diferença só é
considerada descontinuidade se o valor da operação realizada for superior ao valor
definido pelo limiar. Quanto maior for o valor deste limiar, menor a quantidade de
descontinuidades encontradas na imagem [2].
Assim como os algoritmos de threshold, os algoritmos de detecção de
bordas necessitam que as bordas estejam em condições de serem analisadas.
Bordas deformadas corrompem os resultados deste, embora, computacionalmente
falando, este apresente um baixo custo se comparados aos métodos por
crescimento de regiões.
Crescimento de regiões – divide a imagem em regiões através de
agrupamento de pixels vizinhos, uma vez que estes apresentem intensidades
semelhantes. Tem por objetivo produzir regiões coerentes (permitindo alguma
flexibilidade de variação dentro da região) com o maior tamanho possível (número
pequeno de regiões) [2].
Os dois principais métodos de segmentação por crescimento de regiões são
o Watersheds (divisor de águas) e o Algoritmo do Funcional de Mumford e Shah
[16].
Contornos Ativos – é aplicado um contorno inicial sobre o objeto, sob a
forma de curvas spline, que vai sendo iterativamente modificado, expandido e
reduzido de acordo com uma função de energia, para tomar a forma do objeto que
se deseja segmentar [2]. Um dos modelos de contorno mais utilizados é o modelo
snake, que é um tipo particular de modelo deformável no qual uma curva inicial é
22
deformada em direção à borda desejada pela ação de forças internas e externas a
ele [1].
Para a solução apresentada nesta proposta, optou-se por desenvolver uma
segmentação baseada em crescimento de regiões, e para isto foi utilizado o
algoritmo de Watersheds.
O algoritmo de segmentação Watersheds é baseado em crescimento de
regiões, onde a imagem é vista como um relevo topográfico e é inundado com água,
o que permite a formação de bacias de captação e de linhas wathersheds (linhas
divisoras de água), particionando, assim, a imagem em diversas regiões.
7.2 Segmentação por watersheds
A segmentação por watersheds foi inicialmente foi proposta por Digabel e
Lantuéjoul [17], apud Roerdink & Meijster [18], e posteriormente melhorada por
Beucher e Lantuéjoul [17]. Essa abordagem vem do princípio de que uma imagem
em níveis de cinza pode ser vista como um relevo topográfico, formado por vales,
que representam as regiões mais escuras da imagem, e por montanhas, que
representam as porções mais claras [18].
A técnica de watersheds baseia-se no princípio de inundação de relevos
topográficos [1], onde a inundação dos vales, na imagem, proporciona a formação
de linhas divisoras de água, montanhas, separando a imagem em regiões conexas.
É possível visualizar a inundação de duas maneiras distintas: a água vinda de cima,
como se fosse chuva; ou vinda de baixo, como se o relevo estivesse perfurado nos
pontos de altitude mínima e fosse imerso em um lago [16] e [18].
Conforme as bacias vão sendo inundadas, água proveniente de diferentes
bacias se encontram, formando, nos pontos de encontro, represas ou linhas
divisoras de águas, as chamadas watersheds [2]. Quando a água atinge o maior
pico no relevo, o processo termina [13]. O resultado desta operação é uma imagem
particionada a partir de suas bacias topográficas, assim como mostra a Figura 3
abaixo:
23
Figura 3 - Linhas divisórias, mínimos e bacias de captação em relevo topográfico. Fonte: [6].
Para que esta técnica seja melhor compreendida será necessária
apresentação de alguns conceitos básico. São eles:
Distância Geodésica – é a distância medida entre dois pontos existentes
numa mesma “bacia de inundação” respeitando as formas do relevo.
Matematicamente, a distância geodésica entre dois pontos de um conjunto A, dA (a,
b) (Eq. 1) é o caminho mínimo, entre todos os caminhos, de a até b [2]. Sendo B um
subconjunto de A:
dA(a, B) = MIN bB (dA(a,b)) (1)
Zonas de influências geodésicas – a partir do calculo da distância geodésica
é possível definir as zonas de influências geodésicas. Fazendo B ⊆ A ser
24
particionado em k componentes conectados Bi, i = 1, ..., k, a zona de influência
geodésica do conjunto Bi dentro de A é definida como (Eq. 2):
IZA(Bi) = {p ∈ A|∀j ∈ [1...k]/i : dA(p,Bi) < dA(p,Bj)} (2)
A união de todas as zonas de influência formam o conjunto IZA(B). De
acordo com a equação 3, o complemento desse conjunto em relação ao conjunto A
define um outro conjunto, denominado SKIZ (skeleton by influence zones) [2] (Eq. 3):
SKIZA(B) = A / IZA(B) [2] (3)
O SKIZA é composto pelos pontos que estão equidistantes de duas ou mais
zonas de influência. Nesse ponto, pode-se perceber a relação com as watersheds,
que também são linhas formadas por pontos equidistantes de dois ou mais mínimos
regionais [19].
Quando uma imagem é segmentada por watersheds a partir de seu
gradiente morfológico, é obtida uma imagem super segmentada, pois, segundo
Klava [6], o gradiente morfológico apresenta muitos mínimos locais, devido aos
ruídos e texturas dos objetos da imagem. Para minimizar este problema é proposta
a criação de marcadores na imagem original. A função dos marcadores é definir uma
área com um único mínimo local, de maneira a substituir os mínimos gerados pelo
gradiente morfológico.
Também pode ser descrita como uma simulação de imersão, mas ao invés de
fazer furos nos mínimos locais, furamos os pixels correspondentes aos marcadores.
Dessa maneira, o problema de segmentação fica reduzido ao problema de achar os
marcadores apropriados [6].
25
8 MÉTODOLOGIA DE DESENVOLVIMENTO
Como mencionado anteriormente, foi utilizado um software mediador que já
possui métodos e classes que implementam uma segmentação através de algoritmo
de watershed.
A ferramenta SegmentIt [6] permite o tratamento da imagem através de
filtros, geração de marcadores via interface gráfica e aplicação de segmentação
através do marcador gerado. Para isto esta disponibiliza de maneira modular,
classes e métodos para tratamento de imagens digitais. Na Figura 4 é apresentada a
interface do SegmentIt [6], incluindo as 3 fases do processo de segmentação:
Figura 4 - Interface do software SegmentIt. Fonte: [6].
Para desenvolvimento do processo proposto foram utilizados alguns
métodos específicos das classes do SegmentIt [6], descritos a baixo:
br.usp.ime.klava.segmentit.filters.ColorToGray – classe que possui
métodos para conversão de uma imagem colorida para uma imagem equivalente em
níveis de cinza.
br.usp.ime.klava.segmentit.filters.MorphologicalGradient – classe que
possui métodos que realçam as bordas da imagem através de transformação por
dilatação e erosão.
1º Passo - Imagem Original 2º Passo - Criando um marcador 3º Passo - Resultado da Segmentação
26
br.usp.ime.klava.segmentit.gui.MarkersEditor – classe que possui
métodos para criação e manipulação de marcadores.
br.usp.ime.klava.segmentit.watershed.WatershedFromMarkers – classe
que possuí métodos para segmentação de imagens watersheds a partir de
marcadores.
br.usp.ime.klava.segmentit.util.MatrixImagesUtils – classe que possui
métodos para interpretação de valores de matrizes de piexels e conversão em
arquivo de imagem.
Para solucionar o problema proposto foram planejados dois estudos de
caso:
1. Criar um marcador padrão através da interface gráfica e gerar um
processo que o aplique este marcador a todas as imagens do banco;
2. Criar um processo automatizado que gere via software um marcador por
imagem do banco e aplique-o na imagem de origem.
Para dar inicio ao processo de segmentação primeiramente foi necessário
estruturar e organizar o banco de dados de imagens, fornecido pela organização
ImageClef [7], em diretórios que agrupassem e identificassem as imagens de mesma
classe de folhas, pois no banco original as imagens encontram-se agrupadas em
apenas dois diretórios: Test e Train, e suas classes de agrupamentos são
identificadas através de um arquivo txt de índice, que relaciona a classe com o nome
da imagem. Exemplo: “Acer platanoides 3444.jpg 4254.jpg 4864.jpg ... n.jpg”, sendo
n aleatório. Para isto foi criado o Algoritmo 1 apresentado a baixo.
27
Função organizarImagens ();
Variáveis
arquivo: Arquivo; //arquivo de entrada (indice de agrupamento de imagens)
diretório: Texto; //local onde os arquivos a serem organizados estão armazenados
repositório: Arquivo; //arquivo com caminho + nome da pasta onde o resultado da operação será armazenado
textoGuia: Scanner; //objeto java utilizado para leitura de arquivos texto
Inicio
escolhaArquivo();
Se (arquivo == nulo) então
retorna;
Fim-Se
Scanner textoGuia = nulo;
Tentar
textoGuia = novo Scanner (arquivo);
Exceção (ExceçãoDeArquivoNãoExistente e)
Imprime (“Encontrou o erro [” + e + “] ao tentar criar objeto Scanner.”);
Fim-Tentar. escolhaDiretório();
Se (diretório.éVazio()) Então
retorna;
Fim-Se
Enquanto (textoGuia.temProximaLinha())
Texto linha = textoGuia.proximaLinha();
Texto nomeDiretório = “”;
Texto[] listaNomesImagens = novo Texto[0];
Para i = 0 Até linha.tamanho() Faça
Se (Caracter.numerico(linha.caracterDe(i)) Então
nomeDiretório = linha.subTexto(0, i).cortar();
listaNomesImagens = linha.subTexto(i).dividir(“/*caracter espaço*/ “);
break;
Fim-Se
Fim-Para
Arquivo repositório = novo Arquivo (diretório + “\” + nomePasta + “\”);
Se (!repostitório.existe()) Então
repositório.criaRepositório();
Fim-se
Para Texto s Em listaNomesImagens Faça
arquivo = novo Arquivo (diretório + “\” + s)
Se (!arquivo.existe()) Então
Arquivo f = novo Arquivo (repositório.pegarCaminho() + “\” + s);
Se(!f.existe()) Então
Tentar
f.criarNovoArquivo();
Exceção (ExceçãoDeEntradaSaida e)
Imprime (“Encontrou o erro [” + e + “] ao tentar criar arquivo em: ” + f.pegarCaminho());
Fim-Tentar
28
Fim-Se
Tentar
Arquivo.copiar(arquivo.paraCaminho(),
f.paraCaminho(),
OpçãoDeCópiaPadrão.SUBISTITUIR_EXISTE, OpçãoDeCópiaPadrão.COPIAR_ATRIBUTOS);
arquivo.delete();
Exceção (ExceçãoDeEntradaSaida e)
Imprime (“Encontrou o erro [” + e + “] ao tentar copiar arquivo.”);
retorna;
Fim-Tentar
Fim-Se
Fim-Para
Fim-Enquanto
Arquivo[] listaArquivosXML = pegarListaDeArquivosXML();
Para Arquivo f Em listaArquivosXML Faça
f.delete();
Fim-Para
Imprime (“Organizou banco de imagens com sucesso.”);
Fim.
Algoritmo 1: Organizar e agrupar imagens por classes de folhas.
O segundo passo foi a criação de um processo que fosse capaz de navegar
entre os diretórios de imagens partindo de um diretório raiz, que será descrito nos
Algoritmo 2, 3 e 4.
Função açãoMenuArquivo.aplicarSegmentaçãoAutomática (argumento : EventoAção);
Variáveis
Argumento : EventoAção; //objeto que representa um evento acionado via interface do software
diretório: Texto; //caminho para o diretório raiz do banco de imagens
dir: Texto; //armazena temporariamente o caminho para o diretório raiz do banco de imagens
títuloGráfico: Texto; //variável que armazena o título que irá aparecer na imagem do gráfico
legendaGráfico: Texto; //variável que armazena a legenda que irá aparecer na imagem do gráfico
nomeArquivoGráfico: Texto; //nome do arquivo de imagem do gráfico que será salvo em disco
larguraImagemGráfico: Inteiro; //largura da imagem do gráfico
alturaImagemGráfico: Inteiro; //altura da imagem do gráfico
tempo: long; //variável que irá armazenar tempo de execução do método de segmentação
Inicio
ProcessamentoAutomaticoArquivos auto = novo ProcessamentoAutomáticoArquivos();
auto.escolherDiretório();
Se (! ProcessamentoAutomáticoArquivos.diretório.igual(“.\imagens”)) Então //imagens é o diretório padrão do projeto
dir = ProcessamentoAutomáticoArquivos.diretório;
29
títuloGráfico = “”;
legendaGráfico = “”;
nomeArquivoGráfico = “”;
larguraImagemGráfico = 1366; //largura máxima da resolução da tela
alturaImagemGráfico = 768; //altura máxima da resolução da tela
EscolhaTipoMarcador();
Escolher (ProcessamentoAutomáticoArquivos.pegarTipoMarcador)
Caso ProcessamentoAutomáricoArquivos.TipoMarcado.circulo:
títuloGráfico = “Resultado de segmentação para marcador tipo circulo”;
nomeArquivoGráfico = “resultadoParaMarcadorCirculo.png”;
pausar;
Caso ProcessamentoAutomáricoArquivos.TipoMarcado.cruz:
títuloGráfico = “Resultado de segmentação para marcador tipo cruz”;
nomeArquivoGráfico = “resultadoParaMarcadorCruz.png”;
pausar;
Caso ProcessamentoAutomáricoArquivos.TipoMarcado.tridente:
títuloGráfico = “Resultado de segmentação para marcador tipo tridente”;
nomeArquivoGráfico = “resultadoParaMarcadorTridente.png”;
pausar;
Fim-Escolher
tempo = Sistema.tempoAtualMiliSegundos();
auto.aplicarAutoSegmentacaoRecursiva(
novo Arquivo (ProcessamentoAutomáricoArquivos.diretório),
nulo);
tempo = (Sistema.tempoAtualMiliSegundos() – tempo) / 1000;
títuloGráfico = “ (Número de imagens processadas: “ +
auto.pegarNumeroImagensProcessadas() +
“ -> Tempo execução: “ + tempo + “ s)”;
ProcessamentoAutomáricoArquivos.diretório = dir;
auto.imprimirImagemEmArquivo(
títuloGráfico, legendaGráfico, nomeArquivoGráfico,
larguraImagemGráfico, alturaImagemGráfico);
Fim-Se
Fim
Algoritmo 2: Ação ao clicar no botão “Aplicar segmentação automática” do menu “Arquivo”.
Função aplicarAutoSegmentacaoRecursiva (nomeDiretório: Arquivo, marcador: Arquivo);
Variáveis
nomeDiretório: Arquivo; //pasta raiz do banco de imagens
marcador: Arquivo; //imagem de marcador padrão;
listaDiretóriosIgnorados: ListaTexto; //lista com nomes de diretórios criado pelo processo
diretório: Texto; //caminho para a pasta raiz do banco de imagens
listaResultados: ResultadosSegmentação; //objeto composto de nomeClasseFolha: Texto; resultado: Double, para armazenar os resultados obtidos no processo de segmentação de uma determinada classe de folha do banco de imagens
numeroDiretórios: Inteiro; // variável que armazena a quantidade de diretórios da raiz do
30
banco de imagens
resultadoSegmentação: Double; //variável que recebe a média calculada da porcentagem de acerto do processo sobre uma classe de folha
Inicio
se (listaDiretóriosIgnorados = nulo) então
listaDiretóriosIgnorados = nova Lista<Texto>();
listaDiretóriosIgnorados.adicionar(“ImagensFiltradas”);
listaDiretóriosIgnorados.adicionar(“ImagensMarcadores”);
listaDiretóriosIgnorados.adicionar(“ImagensSegmentadas”);
listaDiretóriosIgnorados.adicionar(“ResultadosSegmentação”);
Fim-Se
numeroDiretórios = pegarListaDeDiretórios(nomeDiretório.pegarCaminho()).tamanho();
Para i = 0 Até numeroDiretórios Faça
AplicarAutoSegmentacaoRecursiva (pegarItemDiretório(
diretório.pegarCaminho(), i);
Fim-Para
Se (!listaDiretóriosIgnorados.contém(nomeDiretório.pegarNome())) Então
diretório = nomeDiretório.pegarCaminho();
Se (listaResultados = nulo) Então
listaResultados = nova Lista<ResultadosSegmentação>();
Fim-Se
resultadoSegmentação = aplicarSegmentaçãoAutomática(marcador);
Se (resultadoSegmentação <> -1) Então //-1 considerado erro quando o número de imagens de um diretório é 0
listaResuldados.adicionar(
novo ResultadoSegmentação(nomeDiretório.pegarNome(), resuldadoSegmentação));
Fim-Se
Imprime(“Finalizada segmentação no diretório: “ + nomeDiretório);
Fim-Se
Fim
Algoritmo 3: Navegação recursiva pelos diretórios do banco de imagens.
Tipo Double = Objeto que representa o valor em porcentagem da média de acertos do processo após terminar de segmentar uma classe de folha;
Função aplicarSegmentaçãoAutomática (marcador: Arquivo) : Double;
Variáveis
númeroImagensProcessadas: Inteiro; //contador de imagens processadas
marcador: Arquivo; //imagem de marcador padrão;
diretório: Texto; //caminho diretório raiz de uma classe de imagem
númeroImagens: Inteiro; //variável que armazena a quantidade de imagens do diretório
dir: Texto; //variável que armazena o caminho para o diretório raiz da classe da folha que está sendo processada
porcentagemAcerto: Double; //variável que calcula uma somatória dos valores de porcentagem de acerto calculados sobre uma classe de folha
arquivo: Arquivo; //armazena uma imagem existente dentro do diretório de uma classe de folha
imagemMarcador: BufferImagem; //armazenamento de uma imagem de marcador em memória
31
Inicio
númeroImagens = pegarListaImagens().tamanho;
numeroImagensProcessadas += númeroImagens;
dir = diretório;
porcentagemAcerto = 0;
Para i = 0 Até númeroImagens Faça
diretório = dir;
arquivo = pegarArquivo(i);
imagemMarcador = (marcador = nulo) ? criarMarcador(arquivo) : marcador;
aplicarFiltros(arquivo);
diretório += “\ImagensFiltradas\”;
arquivo = pegarArquivo(i); //carrega no objeto arquivo imagem filtrada
porcentagemAcerto = aplicarMascara(arquivo, imagemMarcador);
Fim-Para
Retorna (número <> 0) ? porcentagemAcerto / númeroImagem : (-1);
Fim
Algoritmo 4: Aplicação de processo de segmentação automático em um diretório de imagem.
Em ambos os estudos de caso citados a cima, foi percebida a necessidade
de criar um método para filtragem e conversão da imagem a ser segmentada em
uma imagem monocromática equivalente para um melhor aproveitamento dos
métodos de segmentação desenvolvidos por Klava [6]. Para isto foram
desenvolvidos algoritmos que fazem a chamada de métodos específicos do
SegmentIt [6], que serão apresentados a seguir. O Algoritmo 5 implementa a
aplicação de métodos para conversão de imagem e realce de bordas, são eles:
- ColorToGray().filter(BufferedImage) – Este método retorna um objeto
BufferedImage e implementa um filtro que é responsável pela conversão de imagens
em modelos de cor RGB para imagens em modelo de cor em níveis de cinza, onde o
parâmetro é um buffer do arquivo de imagem.
- MorphologicalGradient().filter(BufferedImage) – Este método retorna um
objeto BufferedImage e implementa um filtro que é responsável pelo realce das
bordas da imagem, onde o parâmetro é um buffer da imagem. A partir deste temos
uma melhoria na considerável destacando as bordas e deixando a imagem mais
nítida.
32
Função aplicarFiltros (arquivo : Arquivo);
Variáveis
arquivo: Arquivo; //arquivo de entrada (imagem original)
diretório: Texto; //caminho da raiz de uma classe de folha
repositório: Arquivo; //arquivo com caminho + nome da pasta onde o resultado da operação será armazenado
buffer: BufferImagem; // objeto capaz de acessar um arquivo de imagem e armazenar em memória
Inicio
repositório = novo Arquivo (diretorio + “\Imagens Filtradas”);
Se (! repositório.existe()) Então
repositório.criaRepositório();
Fim-Se
buffer = LerArquivo (arquivo) ;
buffer = ConverterCinza(buffer);
Tentar
buffer = GradienteMorfológico().filtrar(buffer);
Exceção (ExceçãoCorDeImagem e)
Imprime (“Encontrou o erro [” + e + “] ao tentar realçar bordas.”);
Fim-Tentar
Se (buffer <> nulo) Então
Se (EscreverArquivo (buffer, arquivo, repositório) = falso) Então
Imprime (“Erro de escrita de imagem em disco.”);
Fim-Se
Senão
Imprime (“Erro de leitura”);
Fim-Se
Fim
Algoritmo 5: Conversão para níveis de cinza e realce de bordas.
Já o Algoritmo 6, implementa a aplicação de um método para segmentação
e um método criação da imagem segmentada, são eles:
- WatershedFromMarkers().byIFT(BufferedImage,BufferedImage,Connecti
vity, LabelingCriterion) – este método retorna uma matriz de pixels (Pixels[][]) e
implementa a segmentação por watersheds, onde o primeiro parametro é um buffer
da imagem filtrada, o segundo é um buffer da imagem do marcador, o terceiro é um
enum representa a conectividade entre os pixels vizinhos e o quarto é um enum que
representa o critério de label utilizado na função de marcadores.
- MatrixImagesUtils().paintWatershed(Pixel[][], Color, Color) – este método
retorna um objeto BufferedImage e é responsável pela impressão de um buffer com
a imagem segmentada, onde o primeiro parâmetro é uma matriz de pixel, o segundo
33
é a cor da região watershed e o terceiro é a cor do fundo da imagem (região
considerada fora do watershed).
Tipo Double = Objeto que representa o valor em porcentagem de acerto do processo após terminar de segmentar uma imagem; Função aplicarWatershedsPorMarcador (arquivo : Arquivo, marcador : BufferImagem); Variáveis arquivo: Arquivo; //arquivo de entrada (imagem filtrada) marcado: BufferImagem; //objeto capaz de acessar um arquivo de imagem e armazenar em
memória (imagem de marcador) origem: Arquivo; //arquivo com o caminho da imagem original matriz: Pixel[][]; //matriz de pixels buffer: BufferImagem; // objeto capaz de acessar um arquivo de imagem e armazenar em memória
(imagem filtrada) repositório: Arquivo; //arquivo com caminho + nome da pasta onde o resultado da operação será armazenado Início
origem = novo Arquivo (arquivo.pegarPaiArquivo ().paraTexto().subtexto(0,
arquivo.pegarPaiArquivo().paraTexto().ultimoIndexDe(“\”)) + “\” + arquivo.pegarNome());
matriz = novo Pixel [aberto][aberto]; buffer = LerArquivo(arquivo); Tentar matriz = WatershedsPorMarcador().porIFT (
buffer, marcador, Conectividade.CONECTIVIDADE_8, CriterioParaLabel.COR_COMPONENTE_CONECTADO);
Exceção (ExceçãoCorImagem e) Imprime (“Encontrou o erro [” + e + “] ao tentar segmentar a imagem.”); Fim-Tentar buffer = novo MatrizImagensUtils().pintarImagemSegmentada (
matriz, Cor.vermelho, EspacoCores.HUES) repositório = novo Arquivo (origem.pegarPaiArquivo() + “\Imagens Segmentadas”); Se (! repositório.existe()) Então
repositório.criaArquivo(); Fim-Se Se (EscreverArquivo (buffer, arquivo, repositório) = falso) Então
Imprime (“Erro de escrita”); Fim-Se arquivo = novo Arquivo (repositório.pegarCaminho() + “\” + arquivo.pegarNome()); Retorna pegarPorcentagemAcerto(arquivo);
Fim
Algoritmo 6: Aplicação de watersheds a partir de um marcador
Para realização dos testes preliminares das funcionalidades desenvolvidas
nos Algoritmos 5 e 6, optou-se por utilizar a Figura 5 como base.
34
Figura 5 – Folha da classe Quercus Ilex. Fonte: [7].
Ao se aplicar o Algoritmo 5 sobre a Figura 5 foi obtido o seguinte resultado
apresentado na Figura 6. Note que a aplicação do método
ColorToGray().filter(BufferedImage) converteu uma imagem de formato RGB em
uma imagem equivalente em formato monocromático, e que a aplicação do método
MorphologicalGradient().filter(BufferedImage) além de realçar as bordas da imagem
ainda inverteu as cores do fundo, para melhor destaque das bordas realçadas.
35
Figura 6 - Resultado da aplicação do Algoritmo 5 na Figura 5.
Para possibilitar a aplicação do Algoritmo 6 é necessário a criação de uma
imagem de marcador, que irá indicar qual a área de interesse da Figura 5. Isto é
possível realizar via interface, utilizando as seguintes ferramentas do SegmentIt [6]:
Menu arquivo → Abrir – Acessa e carrega a imagem na área de trabalho
do programa.
Pincel – Com essa ferramenta é possível desenhar as áreas de interesse
na imagem. A partir da definição desta é necessário marcar um ponto fora da área
para que seja calculada a distinção. O resultado desta ação é uma imagem
semelhante ao segundo passo demonstrado na Figura 4.
Menu arquivo → Salvar imagens de marcadores – Salva somente a
imagem criada com pincel.
Assim após realizar estes passos, obtemos uma imagem semelhante à
apresentada na Figura 7.
36
Figura 7 - Imagem de marcador gerada via interface do SegmentIt [6].
Para conseguir aplicar esta imagem de marcador em todo o banco de
imagem, assim como estabelecido no 1º estudo de caso, foi criado o Algoritmo 7.
Através deste algoritmo é possível enviar o marcador (Figura 7) como parâmetro
para a função WatershedFromMarkers().byIFT (BufferedImage, BufferedImage,
Connectivity, LabelingCriterion), que por sua vez, o compara com a imagem que se
deseja segmentar, também recebida por parâmetro. Esta função percorre a imagem
de marcação e considera que cada continuidade marcada é um vale de watershed
diferente, como pode ser notado na Figura 4, onde é demonstrado o processo
manual. A forma que acompanha o contorno da folha é considerada uma região e a
forma que está na perpendicular acompanhando a borda da imagem é considerada
outra região, assim, todos os pixels com certa proximidade da região marcada que
possua características semelhantes aos pixels sobre a região marcada é
considerada parte de mesma região.
37
Função açãoMenuArquivo.aplicarSegmentaçãoAutomáticaPorMarcador
(argumento : EventoAção);
Variáveis
Argumento : EventoAção; //objeto que representa um evento acionado via interface do software
diretório: Texto; //caminho para o diretório raiz do banco de imagens
dir: Texto; //armazena temporariamente o caminho para o diretório raiz do banco de imagens
títuloGráfico: Texto; //variável que armazena o título que irá aparecer na imagem do gráfico
legendaGráfico: Texto; //variável que armazena a legenda que irá aparecer na imagem do gráfico
nomeArquivoGráfico: Texto; //nome do arquivo de imagem do gráfico que será salvo em disco
larguraImagemGráfico: Inteiro; //largura da imagem do gráfico
alturaImagemGráfico: Inteiro; //altura da imagem do gráfico
tempo: long; //variável que irá armazenar tempo de execução do método de segmentação
Inicio
ProcessamentoAutomaticoArquivos auto = novo ProcessamentoAutomáticoArquivos();
auto.escolherArquivoMarcador();
auto.EscolherDiretório();
Se (! ProcessamentoAutomáticoArquivos.diretório.igual(“.\imagens”)) Então //imagens é o diretório padrão do projeto
dir = ProcessamentoAutomáticoArquivos.diretório;
títuloGráfico = “Resuldados de segmentação para marcador padrão”;
legendaGráfico = “”;
nomeArquivoGráfico = “resultadoMarcadorPadrão.png”;
larguraImagemGráfico = 1366; //largura máxima da resolução da tela
alturaImagemGráfico = 768; //altura máxima da resolução da tela
tempo = Sistema.tempoAtualMiliSegundos();
auto.aplicarAutoSegmentacao (
novo Arquivo (ProcessamentoAutomáricoArquivos.diretório);
tempo = (Sistema.tempoAtualMiliSegundos() – tempo) / 1000;
títuloGráfico = “ (Número de imagens processadas: “ +
auto.pegarNumeroImagensProcessadas() +
“ -> Tempo execução: “ + tempo + “ s)”;
ProcessamentoAutomáricoArquivos.diretório = dir;
auto.imprimirImagemEmArquivo(
títuloGráfico, legendaGráfico, nomeArquivoGráfico,
larguraImagemGráfico, alturaImagemGráfico);
Fim-Se
Fim
Algoritmo 7: Ação ao clicar no botão “Aplicar segmentação automática” do menu “Arquivo”.
Ao aplicar o Algoritmo 7 foi verificado que não seria possível a segmentação
via algoritmo de watersheds utilizando esta técnica, pois, como pode ser notado nos
passos apresentados na Figura 4, a posição do marcador em função da imagem
original é o responsável pela identificação dos vales de watersheds. Ao aplicar o
38
marcador apresentado na Figura 7 em outras imagens do banco de imagens [7],
este apresenta um deslocamento com relação as regiões de interesse, marcadas na
imagem padrão (Figura 5), o que ocasiona falha na identificação da posição da folha
com relação ao fundo e erro de segmentação.
Figura 8 – Folha de classe não relacionada em
índice. Fonte: [7].
Figura 9 – Folha da classe Broussonetia
papyrifera. Fonte: [7].
Sendo assim, o foco foi direcionado ao 2º estudo de caso planejado neste
trabalho, gerar uma imagem de marcação personalizada para cada imagem do
banco de imagens [7]. Desta forma foram criados os Algoritmos 8 e 10, que utilizam
o seguinte objeto do SegmentIt [6]:
- MarkersEditor (int, int) – este objeto cria um objeto BufferedImage do
tipo ARGB, com altura e largura de acordo com os parâmetros. Implementa,
também, métodos para pintar os pontos de interesse e preencher os pixels da
imagem de acordo com a cor do marcador.
39
Tipo BufferImagem = Objeto que representa um arquivo de imagem armazenado em memória; Função criarMarcador (arquivo : Arquivo): BufferImagem; Variáveis arquivo: Arquivo; //arquivo de entrada marcador: EditorMarcador; //objeto capaz de desenhar e criar arquivo de marcador raster: Rastreamento; //objeto de capaz de navegar na imagem e obter propriedades dos
pixels de determinada coordenada buffer: BufferImagem; //objeto capaz de acessar o arquivo de imagem e armazena em
memória diretório: Texto; //variável que armazena o caminho para o diretório raiz do banco de imagens repositório: Arquivo; //arquivo com caminho + nome da pasta onde o resultado da operação
será armazenado altura: Inteiro; //inteiro que armazena a altura da imagem largura: Inteiro; //inteiro que armazena a largura de uma imagem limiarInterativo: Double[]; //variável que recebe o valor do limiar da imagem fundo: Ponto; //objeto composto que armazena as coordenadas x,y do primeiro ponto de fundo
encontrado na imagem contadorPixelsLimiar: Inteiro; //variável que armazena a quantidade de pixels que possuem
valor menor que o recebido na variável limiarInterativo, considerada imagem da folha;
pixel: inteiro[]; //vetor de inteiro que representa o valor de nível de cinza de um ponto i: inteiro; //contador utilizado para indicar o ponto x da imagem que está sendo acessado pelo
ciclo de interação j: inteiro; // contador utilizado para indicar o ponto x da imagem que está sendo acessado pelo
ciclo de interação Início
buffer = lerArquivo(arquivo); raster = buffer.pegarRaster(); altura = raster.pegarAltura(); largura = raster.pegarLargura(); marcador = novo EditorMarcador(largura, altura); marcador.SetarCorPincel(Cor.verde); marcador.SetarDiametroPincel(1); limiarInterativo = pegarHistograma(arquivo); fundo = nulo; contadorPixelsLimiar = 0; Para i = 0 Até largura Faça
Para j = 0 Até altura Faça inteiro[] pixel = novo Inteiro[3]; raster.pegarPixel(i, j, pixel); Se (pixel[0] < limiarInterativo[0]) Então
marcador.pintar(i, j); contadorPixelsLimiar ++;
Senão Fundo = novo Ponto (i, j);
Fim-Se Fim-Para
Fim-Para //marcador = filtrarMarcador(((BufferImagem) marcador.pegarImagem()).pegarRaster()); marcador.pintar(fundo.pegarX(), fundo.pegarY); repositório = novo Arquivo (diretório + “\ImagensMarcadores”); se (! repositório.existe()) então
repositório.criaRepositório(); se (EscreverArquivo (buffer, arquivo, repositório) = falso) então
Retorna nulo; Retorna (BufferedImage) marcador.PegarImagem();
Fim Algoritmo 8: Criar marcador a partir das imagens de entrada
40
Note que no Algoritmo 8 foram utilizadas técnicas de limiarização, conforme
descrição na sessão 7, a fim de binarizar a imagem original e obter com maior
exatidão a área da folha e suas coordenadas de localização. Então, foi necessária a
criação do Algoritmo 9 que é capaz de gerar um objeto javax.media.jai.Histogram, da
API JAVAX, e através deste, obter com exatidão o valor de limiar a ser utilizado
como parâmetro da binarização.
Tipo Double = Objeto que representa o valor do limiar calculado pelo objeto histograma;
Função pegarHistograma (arquivo : Arquivo);
Variáveis
arquivo: Arquivo; //arquivo de entrada (imagem original)
imagem: PlanarImagem; //representa imagem carregada em memória
bandas: Inteiro[]; //quantidade de bandas representadas no histograma
baixo: Double[]; //mínimo valor de banda representada no histograma
alto: Double[]; //máximo valor de banda representada no histograma
blocoParâmetro: BlocoParâmetros; //objeto composto com as propriedades necessárias para criação do histograma
render: RenderOp; //renderização de imagem contendo a propriedade histograma em memória
histograma: Histograma; //propriedade histograma do objeto renderização
Inicio
Sistema.atribuirPropriedade(“com.sun.media.jai.disableMediaLib", "verdadeiro"); //ativa propriedade da biblioteca que permite renderização em memória
Imagem = JAI.criar(“carregarArquivo”, arquivo.pegarCaminho());
bandas = novo Inteiro[] {256};
baixo = novo Double[]{0};
alto = novo Double[]{256};
blocoParâmetro = novo BlocoParâmetro();
blocoParâmetro.adicionarCódigo(imagem);
blocoParâmetro.adicionar(nulo);
blocoParâmetro.adicionar(1);
blocoParâmetro.adicionar(1);
blocoParâmetro.adicionar(bandas);
blocoParâmetro.adicionar(baixo);
blocoParâmetro.adicionar(alto);
render = JAI.criar(“histograma”, blocoParâmetro, nulo);
histograma = (Histograma) render.pegarPropriedade(“histograma”);
Retorna histograma.pegarLimiarInterativo();
Fim
Algoritmo 9: Algoritmo para calculo de limiar.
Aplicando o Algoritmo 8 na Figura 5 foi obtido o seguinte resultado,
apresentado na Figura 10:
41
Figura 10 - Resultado da aplicação do Algoritmo 8 na Figura 5.
Com estes algoritmos foi possível obter uma imagem fiel e binarizada com
relação à imagem original, apenas definindo um limiar para segmentação [15] e [20].
É possível também se obter um valor aproximado da quantidade de pixels que
compõe a região de interesse, assim como obter uma imagem segmentada em 2
níveis, fundo e folha. Porém, como pode ser notado, não se possui exatidão com
relação às coordenadas de contorno da imagem, pois no momento de transição,
entre fundo e região de interesse, os pixels variam muito seu valor com relação ao
seu vizinho. A segmentação via algoritmo de watersheds visa conseguir delimitar a
área de contorno que separa 2 regiões com variação de apenas 1 pixel, com isso a
segmentação ganha maior confiabilidade. Mas isto não é fácil de conseguir, pois,
como já visto anteriormente, qualquer variação de coordenada do marcador altera a
região marcada e ocasiona erro de segmentação.
Acreditando que devido a alta semelhança do marcador binarizado criado
com o Algoritmo 8 fosse ampliar as chances de acerto do processo de segmentação
via algoritmo de watersheds, decidiu-se aplicar o marcador apresentado na Figura
10 sobre a Figura 6 com o Algoritmo 7, então foi obtido o seguinte resultado:
42
Figura 11 - Resultado da aplicação do marcador (Figura 10) na Figura 6.
Note na Figura 11 que, embora o marcador tenha ficado fiel a região de
interesse da Figura 5, o resultado da segmentação apresentou bem mais de duas
regiões, considerando a borda como uma região isolada de qualquer outra região da
imagem. Considerando que existem apenas duas regiões de interesse na imagem,
folha e fundo, é esperado que a imagem segmentada possuísse apenas duas cores
para diferenciar estas. Este resultado foi obtido devido ao fato de existirem vários
fragmentos de imagem, imperceptíveis a olho nu, no marcador gerado, uma vez que
o Algoritmo 8 marca cada pixel com valor a baixo do limiar de maneira isolada, o que
ocasiona uma supersegmentação. Segundo Klava [6], uma supersegmentação
ocorre quando a imagem segmentada via watersheds apresenta diversos mínimos
locais. Ao aplicar um marcador sem continuidade em uma imagem cada ponto que
se apresentar isolado dos demais gera um mínimo local.
Para criar uma continuidade no marcador e possibilitar sua aplicação na
imagem foi criado o Algoritmo 10. A função deste algoritmo é mapear a imagem de
marcador, obter seus extremos e criar uma marcação continua e interna à área de
interesse.
43
Tipo BufferImagem = Objeto que representa um arquivo de imagem armazenado em memória; Função filtrarMarcador (raster : Rastreamento) : BufferImagem; Variáveis raster: Rastreamento; //objeto de capaz de navegar na imagem e obter propriedades dos
pixels de determinada coordenada oeste: Ponto; //valor de coordenada (x, y) que representa o ponto da borda oeste da região de
interesse mais próximo da extremidade da imagem leste: Ponto; //valor de coordenada (x, y) que representa o ponto da borda leste da região de
interesse mais próximo da extremidade da imagem norte: Ponto; //valor de coordenada (x, y) que representa o ponto da borda norte da região de
interesse mais próximo da extremidade da imagem sul: Ponto; //valor de coordenada (x, y) que representa o ponto da borda sul da região de
interesse mais próximo da extremidade da imagem centro: Ponto; //valor de coordenada (x, y) que representa o ponto central da região de
interesse tipoMarcador: TipoMarcador; //objeto enumerado que define o tipo de marcador que se deseja
criar temporário: EditorMarcador; // objeto capaz de desenhar e criar arquivo de marcador diâmetroPincel: Inteiro; //valor responsável por atribuir um diâmetro ao pincel do marcador altura: Inteiro; //inteiro que armazena a altura da imagem largura: Inteiro; //inteiro que armazena a largura de uma imagem pixel: Inteiro[]; //vetor de inteiro que representa o valor de nível de cinza de um ponto i: Inteiro; //contador utilizado para indicar o ponto x da imagem que está sendo acessado pelo
ciclo de interação j: Inteiro; // contador utilizado para indicar o ponto x da imagem que está sendo acessado pelo
ciclo de interação Início
oeste = novo Ponto (marcador.pegarLargura(), 0); norte = novo Ponto (0, marcador.pegarAltura); leste = novo Ponto (0, 0); sul = novo Ponto (0, 0); centro = novo Ponto (0, 0); largura = marcador.pegarLargura(); altura = marcador.pegarAltura(); raster = ((BufferedImage) marcador.PegarImagem()).pegarRaster(); temporário = novo EditorMarcador (largura, altura); temporário.SetarCorPincel(Cor.verde); temporário.SetarDiametroPincel(diâmetroPincel); Para i = 0 Até largura Faça
Para j = 0 Até altura Faça inteiro[] pixel = novo inteiro[4]; raster.pegarPixel(i, j, pixel); se (pixel[0] = 0 e pixel[1] = 255 e pixel[2] = 0 e pixel[3] = 255) Então
//valores dos pixels correspondente a cor atribuída ao marcador no Algoritmo 8 (Cor.verde)
Se (oeste.pegarX() > i) Então atribuirPonto(oeste, i, j);
Fim-Se Se (norte.pegarY() > j) Então
atribuirPonto(norte, i, j); Fim-Se Se (leste.pegarX() < i) Então
atribuirPonto(leste, i, j); Fim-Se Se (sul.pegarY() < j) Então
atribuirPonto(sul, i, j); Fim-Se
Fim-Se
44
Fim-Para Fim-Para Centro.atribuirX(oeste.pegarX() + ((Inteiro) ((leste.pegarX() – oeste.pegarX()) / 2))); Centro.atribuirY(norte.pegarY() + ((Inteiro) ((sul.pegarY() – norte.pegarY()) / 2))); Escolher (tipoMarcador)
Caso TipoMarcador.cruz: temporário.pintar(centro.pegarX(), centro.pegarY()); temporário.pintar(norte.pegarX(), norte.pegarY()); temporário.pintar(centro.pegarX(), centro.pegarY()); temporário.pintar(sul.pegarX(), sul.pegarY()); temporário.pintar(centro.pegarX(), centro.pegarY()); temporário.pintar(oeste.pegarX(), oeste.pegarY()); temporário.pintar(centro.pegarX(), centro.pegarY()); temporário.pintar(leste.pegarX(), leste.pegarY()); pausar;
Caso TipoMarcador.tridente: temporário.pintar(centro.pegarX(), centro.pegarY()); temporário.pintar(norte.pegarX(), norte.pegarY()); temporário.pintar(centro.pegarX(), centro.pegarY()); temporário.pintar(oeste.pegarX(), oeste.pegarY()); temporário.pintar(centro.pegarX(), centro.pegarY()); temporário.pintar(leste.pegarX(), leste.pegarY()); pausar;
Caso TipoMarcador.circulo: temporário.pintar(centro.pegarX(), centro.pegarY()); pausar;
Fim-Escolher Retorna temporário;
Fim. Algoritmo 10: Filtrar imagem de marcador
A partir da aplicação do Algoritmo 10 na Figura 10, o marcador é capaz de
assumir três formas diferentes, de acordo com cada tipo de marcador selecionado,
assim como é mostrado na Figura 12.
Figura 12 - Resultado da aplicação do Algoritmo 10 na Figura 10.
*Observação: As imagens de marcadores geradas pelo Algoritmo 10 possuem fundo branco, imagens com fundo preto são apenas para destaque do desenho dos marcadores.
45
Sendo assim, ao aplicar o processo de segmentação atribuindo o marcador
tipo circulo gerado pelo Algoritmo 10, com 172 px diâmetro do pincel (valor que
representa distância entre o centro e o limite oeste da folha), foi obtido o resultado
apresentado na Figura 13.
Figura 13 - Resultado do processo de segmentação aplicado na Figura 5.
Ao aplicar-se este algoritmo no banco de dados notou-se cada tipo de
marcador apresenta um comportamento diferenciado para um mesmo grupo de
imagens. Com isso surge a necessidade de se avaliar qual tipo de marcador melhor
se adapta a uma determinada classificação de folhas, para assim poder obter um
maior numero de imagens segmentadas corretamente. Para poder estabelecer um
índice de porcentagem que representasse a eficiência dos marcadores gerados no
processo foi desenvolvido o Algoritmo 11. Este algoritmo compara a quantidade de
pixels encontradas na região de interesse (folha) da imagem limiarizada gerada pelo
Algoritmo 8 com a quantidade de pixels encontradas da região de interesse geradas
pelo Algoritmo 10, para assim resultar num percentual de acerto do método.
Tipo Double = Objeto que representa o resultado calculado em porcentagem; Função pegarPercentualAcerto (arquivo : Arquivo) : Double; Variáveis
46
raster: Rastreamento; //objeto de capaz de navegar na imagem e obter propriedades dos pixels de determinada coordenada
altura: Inteiro; //inteiro que armazena a altura da imagem largura: Inteiro; //inteiro que armazena a largura de uma imagem limiarInterativo: Double[]; //variável que recebe o valor do limiar da imagem contadorPixelsLimiar: Inteiro; //variável que armazena a quantidade de pixels que possuem
valor menor que o recebido na variável limiarInterativo, considerada imagem da folha;
contadorPixelsWatersheds: Inteiro; //variável que armazena a quantidade de pixels que possuem valor maior que o recebido na variável limiarInterativo, considerada imagem da folha;
pixel: inteiro[]; //vetor de inteiro que representa o valor de nível de cinza de um ponto i: inteiro; //contador utilizado para indicar o ponto x da imagem que está sendo acessado pelo
ciclo de interação j: inteiro; // contador utilizado para indicar o ponto x da imagem que está sendo acessado pelo
ciclo de interação Início
raster = lerArquivo(arquivo).pegarRaster(); altura = raster.pegarAltura(); largura = raster.pegarLargura(); limiarInterativo = pegarHistograma(arquivo); contadorPixelsWatersheds = 0; Para i = 0 Até largura Faça
Para j = 0 Até altura Faça inteiro[] pixel = novo Inteiro[4]; raster.pegarPixel(i, j, pixel); Se (pixel[0] > limiarInterativo[0]) Então
contadorPixelsWatersheds ++; Fim-Se
Fim-Para Fim-Para Retorna (contadorPixelsLimiar < contadorPixelsWatersheds ?
contadorPixelsLimiar / contadorPixelsWatersheds : contadorPixelsWatersheds / contadorPixelsLimiar) * 100;
Fim Algoritmo 11: Calcular porcentagem de acerto do método de segmentação
Sendo assim, na próxima sessão serão demonstrados e detalhados os
resultados positivos e negativos obtidos com esta experiência e disposto um gráfico
comparativo demonstrando os resultados atingidos com cada tipo de marcador.
47
9. RESULTADOS E DISCUSSÕES
Nesta seção são demonstrados os resultados experimentais obtidos ao
submeter às imagens do repositório ImageCLEF [7] ao processo desenvolvido ao
longo deste trabalho.
Para um melhor acompanhamento do processo as imagens serão
demonstradas da seguinte forma: (a). Imagem original; (b). Imagem convertida e
com bordas realçadas; (c). Imagem de marcador; (d). Resultado da segmentação. A
seguir, nas Figuras 14, 15, 16, 17, 18 e 19, são demonstrados dois resultados
obtidos no processo de segmentação de uma mesma imagem.
(a) (b) (c) (d)
Figura 14 - Resultado da aplicação do marcador tipo cruz sobre uma amostra da classe de folha Syringa vulgaris. Fonte: [7].
(a) (b) (c) (d)
Figura 15 - Resultado da aplicação do marcador tipo tridente sobre uma amostra da classe de folha
Syringa vulgaris. Fonte: [7].
48
(a) (b) (c) (d)
Figura 16 - Resultado da aplicação do marcador tipo circulo, com 4px de diâmetro, sobre uma
amostra da classe de folha Syringa vulgaris. Fonte: [7].
(a) (b) (c) (d)
Figura 17 - Resultado da aplicação do marcador tipo cruz sobre uma amostra da classe de folha Acer
campestre. Fonte: [7].
49
(a) (b) (c) (d)
Figura 18 - Resultado da aplicação do marcador tipo tridente sobre uma amostra da classe de folha
Acer campestre. Fonte: [7].
(a) (b) (c) (d)
Figura 19 - Resultado da aplicação do marcador tipo circulo, com 4px de diâmetro, sobre uma
amostra da classe de folha Acer campestre. Fonte: [7].
Com isto é possível notar que embora, em alguns casos, o resultado final foi
o mesmo, cada marcador possui um comportamento diferente ao ser aplicado sobre
uma mesma imagem. Sendo assim, foi realizado um experimento onde cada tipo de
marcador foi aplicado em todas as imagens do banco de imagens [7], e assim foi
possível reunir os resultados apresentados nas Figuras 20, 21e 22.
50
Figura 20 - Resultado do processo de segmentação automático com marcador do tipo cruz.
51
Figura 21 - Resultado do processo de segmentação automático com marcador do tipo tridente.
52
Figura 22 - Resultado do processo de segmentação automático com marcador do tipo circulo.
53
Através destes dados é possível direcionar o tipo de marcador a classe de
folha que este obteve maior sucesso, assim aumentando as chances de atingir um
processo de segmentação que consiga atingir percentuais de acerto acima de 90%.
Também é possível notar que, para algumas classes de folhas, como Rhus typhina,
não foi possível atingir um percentual acima de 40%. Isto se dá devido à forma das
folhas destas classes, que dificultam o mapeamento de seus pontos de máximos e
mínimos causando erros no calculo que posicionam os marcadores com relação a
imagem original. Com isso, não foi possível estabelecer um padrão para a aplicação
de um processo segmentação automática, visando segmentar várias classes de
folhas, pois estas classes exigem um tratamento individual de suas formas para
atingir um calculo preciso da localização do marcador em função da imagem original.
Sendo assim, foi possível realizar uma comparação da eficiência de cada
tipo de marcador com relação ao banco de imagens [7]. Os resultados obtidos são
apresentados na Figura 21, que representa o percentual médio da aplicação do
processo com cada tipo de marcador.
Figura 23 – Resultado comparativo da eficiência de cada tipo de marcador, ao ser aplicado no banco de imagens [7].
Marcador tipo circulo
Marcador tipo cruz
Marcador tipo tridente
54
10. CONCLUSÕES
O foco deste trabalho consistiu no desenvolvimento de uma técnica de
segmentação robusta, automatizada e reutilizável.
Um grande progresso foi alcançado ao seguir este caminho. Através de uma
abordagem simples, que utilizou técnicas de conversão de uma imagem colorida em
uma imagem em nível de cinza, realce das bordas da região de interesse,
localização dos extremos desta, criação de um marcador de um marcador sem
interferência humana e aplicação automática em um banco de imagem, foi
alcançado aproximadamente 72% de eficiência no processo, ao utilizar marcador do
tipo circulo, 59%, ao utilizar marcador do tipo cruz e 68%, ao utilizar marcador do
tipo tridente. Cabe agora mapear as falhas do processo e descobrir uma maneira de
padronizar imagens de folhas com formatos mais exóticos, para assim evoluir o
processo desenvolvido.
Será necessário, a partir de agora, aperfeiçoar as técnicas desenvolvidas
para se realizar uma abordagem posterior e conseguir analisar e identificar quais
são os pontos internos de uma região de interesse, pois, conseguindo maior
exatidão na identificação destes pontos, é possível definir quais são as coordenadas
que os marcadores devem ocupar e qual a forma de marcador que melhor se adapta
a classe de folha que se deseja segmentar.
Para isto deverá ser desenvolvida uma técnica de identificação de entrada e
saída da região de interesse baseando-se em técnicas de preenchimentos de
polígonos. A partir dai pode-se pensar em analisar a textura encontrada na região de
interesse e compara-la com o restante da imagem, proporcionando a descoberta de
n regiões semelhantes em uma mesma imagem.
Com isso, está técnica ganharia um range de aplicação muito maior que
somente imagens de folhas. Uma vez que se alcance uma técnica capaz de
identificar imagens de texturas e formas semelhantes em uma imagem complexa,
seria possível utilizar os processos de segmentação desenvolvidos para aplicações
em diversas áreas dos meios biológicos..
55
11 REFERÊNCIAS
[1] J. C. Russ, The Image Processing Handbook, ed 3. ed., Boca Raton: CRC Press, 1998.
[2] G. Peccini e M. C. d'Ornellas, “Segmentação de imagens por Watersheds: Uma implementação Utilizando a Linguagem Java,” [Online]. Available: http://bibliotecadigital.sbc.org.br/download.php?paper=140. [Acesso em 15 12 2011].
[3] S. C. D. Pinto, J. Mena-Chalco, F. Lopes, L. Velho e R. Cesar Junior, “3D facial expression analysis by using 2D AND 3D wavelet transforms,” 2011. [Online]. Available: http://ieeexplore.ieee.org/xpl/articleDetails.jsp?reload=true&arnumber=6115668. [Acesso em 15 10 2011].
[4] R. C. a. W. R. E. Gonzalez, Digital Image Processing, Massachusetts: Addison Wesley Publishing Company, 1992.
[5] F. M. Lopes, “Métodos e técnicas para exploração e análise de bioimagens,” Cornélio Procópio, 2011.
[6] B. Klava, “Ferramenta interativa para segmentação de imagens digitais,” 2006. [Online]. Available: http://www.ime.usp.br/~klava/tfs/tfs_klava.pdf. [Acesso em 10 03 2012].
[7] Conference and Labs of the Evaluation Forum, “Image CLEF Retrivial in CLEF - Plant Identification,” 2011. [Online]. Available: http://www.imageclef.org/2011/plants. [Acesso em 27 04 2012].
[8] Oracle Sun JAVA, Programming in Java Advanced Imaging, Palo Alto, California, 1999.
[9] The Eclipse Foundation, Eclipse Board of Stewards, 2001.
[10] Oracle Sun NetBeans, NetBeans IDE, 2000.
[11] W. K. Pratt, Digital Image Processing: PIKS Inside, New York: John Wiley and Sons, 2001.
[12] J. Facon, Processamento e Análise de Imagens, Paraná: Pontifícia Universidade Católica (PUC), 2001.
[13] F. Meyer, “Topographic distance and watershed lines,” em Signal Processing, 1994, pp. 113-125.
[14] P. Soille, Morphological Image Analysis - Principles and Applications, Barcelona: Springer, 1999.
[15] F. M. Lopes, “Um modelo perceptivo de limiarização de imagens,” 2003. [Online]. Available: http://pessoal.utfpr.edu.br/fabricio/pesquisa/publicacoes/2003-dissertacao-ufpr-uem-fabricio-m-lopes.pdf. [Acesso em 18 8 2011].
[16] A. Wangenheim, “Técnicas de segmentação de imagens por crescimento de regiões (region-growing image segmentation),” 2003. [Online]. Available: http://www.inf.ufsc.br/~visao/regiongrow.pdf. [Acesso em 23 02 2012].
[17] H. Digabel e C. Lantuéjoul, “Iterative algorithms,” em Quantitative analysis of microstructures in materials sciences, biology and medicine, Stuttgart,
56
Chermant, J. L., 1978-1979, pp. 85-99.
[18] J. B. Roerdink e A. Meijster, “The watershed transform: Definitions, algorithms and parallelizations strategies,” Fundamenta Informaticae - Special issue on mathematical morphology, vol. 41, pp. 187-228, 2000.
[19] S. Beucher, “The watershed transformation applied to image segmentation,” em Tenth Pfefferkorn Conference, Scanning Microscopy International, London, 1991.
[20] F. M. Lopes e L. A. Consularo, “A RBFN Perceptive Model for Image Thresholding,” 2005. [Online]. Available: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=1599108. [Acesso em 22 11 2011].
