sumÁrio · 2.1.4.dispositivos reconfiguráveis ... esta pesquisa trata especificamente da...
TRANSCRIPT
SUMÁRIO
1. INTRODUÇÃO........................................................................................................ 13
1.1. Contexto .................................................................................................................... 13 1.2. Problema motivador ................................................................................................. 15
1.3. Objetivos ................................................................................................................... 17 1.4. Metas ......................................................................................................................... 18
1.5. Justificativa ............................................................................................................... 18 1.6. Escopo ....................................................................................................................... 19
1.7. Organização do texto ................................................................................................ 19
2. REVISÃO BIBLIOGRÁFICA ................................................................................. 21
2.1. Conceitos teóricos ..................................................................................................... 21
2.1.1. Representação de uma imagem digital ....................................................................... 21 2.1.2. Interpolação e Reconstrução de imagens ................................................................... 24
2.1.3. Computação Reconfigurável ...................................................................................... 27 2.1.4. Dispositivos reconfiguráveis ...................................................................................... 29
2.1.5. Linguagem de descrição de hardware – VHDL ......................................................... 32
2.2. Implementação de Filtros de Interpolação de Imagens utilizando Computação
Reconfigurável .......................................................................................................... 33
3. ARQUITETURA DE HARDWARE RECONFIGURÁVEL PARA UM
CIRCUITO INTERPOLADOR DE IMAGEM ....................................................... 37
3.1. Análise dos requisitos a serem atendidos pela arquitetura proposta ...................... 37 3.2. Arquitetura proposta para o interpolador ............................................................... 38 3.2.1. Características da Arquitetura do interpolador .......................................................... 43
3.2.2. Exemplo do processo de interpolação unidimensional .............................................. 45 3.3. Codificação da arquitetura em VHDL ..................................................................... 46
3.3.1. Trecho da programação em VHDL do bloco de Gerenciamento de coeficientes ...........
................................................................................................................................. 47
3.3.2. Trecho da programação em VHDL definindo as constantes que irão gerar os
coeficientes de interpolação ....................................................................................... 48
3.3.3. Trecho da programação em VHDL para a geração do sinal d_ena pelo bloco de
Controle ..................................................................................................................... 50
3.3.4. Trecho da programação em VHDL do bloco de processamento da Interpolação ...... 51 3.4. Principais blocos da arquitetura do circuito interpolador ...................................... 51
3.4.1. Bloco de memória de entrada ..................................................................................... 52 3.4.2. Bloco de gerenciamento dos coeficientes ................................................................... 52
3.4.3. Bloco de controle ....................................................................................................... 54 3.4.4. Bloco de processamento da interpolação ................................................................... 55
3.5. Implementação da arquitetura (codificada em VHDL) no FPGA EP2C5F256C6 ..... ................................................................................................................................... 57
4. RESULTADOS ......................................................................................................... 59
4.1. Testes funcionais do bloco de processamento da interpolação ................................ 60 4.2. Testes funcionais do circuito interpolador de imagem ............................................ 64
4.2.1. Interpolador de ordem zero: vizinho mais próximo.................................................... 67 4.2.2. Testes com um interpolador de primeira ordem: Linear ............................................ 71
4.2.3. Testes com um interpolador de terceira ordem: Lanczos ........................................... 75 4.3. Testes com uma imagem real .................................................................................... 79
4.3.1. Teste com interpolação em duas dimensões sobre bloco da imagem .......................... 80
4.3.2. Teste com interpolação linear unidimensional sobre uma imagem ........................... 82 4.4. Considerações finais .................................................................................................. 84
5. CONCLUSÕES ......................................................................................................... 85
5.1. Discussão dos resultados ........................................................................................... 85 5.2. Principais contribuições ............................................................................................ 87
5.3. Trabalhos futuros ..................................................................................................... 88
REFERÊNCIAS ................................................................................................................. 89
13
1. INTRODUÇÃO
Este capítulo apresenta o contexto, o problema motivador, os objetivos, as metas a
serem atingidas, a justificativa e o escopo da pesquisa realizada no PPGEE (Programa de Pós
graduação em Engenharia Elétrica da PUC-Minas), para o projeto de uma arquitetura de
hardware reconfigurável, que permita a utilização de diferentes polinômios ou filtros que
“janelem” a função sinc, para realizar a interpolação de uma imagem digital alterando sua
resolução. Essa arquitetura deverá ser desenvolvida utilizando-se VHDL (VHSIC - Very High
Speed Integrated Circuits; HDL - Hardware Description Language), que é uma linguagem de
descrição de hardware padronizada adequada ao desenvolvimento e simulação de soluções, a
serem implementadas em dispositivos lógicos programáveis, independentemente de
fabricantes ou fornecedores de produtos.
1.1. CONTEXTO
Desde os primórdios da humanidade o homem sente a necessidade de representar o
seu ambiente e a si mesmo sob as mais diversas formas, talvez com o objetivo de perpetuar
seus momentos ou passar suas experiências para as gerações futuras. No início foram
utilizadas técnicas de pintura primitiva em paredes de cavernas, pedaços de pau ou couro de
animais. Com o passar do tempo essas técnicas aprimoraram-se e o ser humano pôde
representar de forma magistral suas imagens através de grandes pintores e escultores. Com a
invenção da fotografia e depois do cinema a facilidade para registrarem-se informações
expandiu-se rapidamente. Com o desenvolvimento da microeletrônica, a utilização de
dispositivos eletrônicos para processar, transmitir, armazenar e exibir imagens vem ocupando
um espaço até há pouco tempo exclusivo de profissionais. Assim, é cada vez mais familiar às
pessoas comuns o acesso a imagens digitais provenientes das mais diversas fontes
(GONZALEZ, 2002). Nos hospitais, os equipamentos eletrônicos, tais como os tomógrafos e
os equipamentos de ressonância, tornaram-se essenciais para a precisão de diagnósticos. Hoje
a câmera fotográfica digital tomou o lugar das câmeras fotográficas tradicionais nos eventos
familiares e profissionais. Controles eletrônicos de velocidade, que fotografam digitalmente o
14
infrator, fazem parte do nosso dia a dia. O DVD (Digital Video Disc) substituiu os antigos
videocassetes agregando mais qualidade, a um custo mais reduzido, às imagens exibidas na
sala de estar. No Brasil de hoje encontra-se em processo de implantação a televisão digital
que certamente provocará uma nova revolução nos hábitos dos brasileiros.
Em todas essas aplicações, a imagem pode ser definida como uma função
bidimensional f(x,y), onde x e y são coordenadas espaciais (plano) e a amplitude de f, em
qualquer par de coordenadas (x,y) é chamada intensidade ou nível de cinza da imagem (no
caso das imagens monocromáticas) naquele ponto (DODGSON , 1992).
Existem dois tipos básicos de imagem: contínua (ou analógica) e discreta (ou digital).
A imagem contínua apresenta uma intensidade que assume um valor real em cada ponto do
plano real. A imagem que é apresentada para o olho humano ou para uma câmera de vídeo,
antes de qualquer processamento, é uma imagem contínua. Imagens digitais somente
apresentam valores de intensidade em um conjunto de posições espaciais discretas e essas
intensidades pertencem a um conjunto discreto de valores. Uma imagem armazenada no
buffer, de uma placa de processamento de vídeo para exibição em uma tela de um
computador, é uma imagem digital (DODGSON , 1992).
Deve-se observar que uma imagem digital é composta por um número finito de
elementos, cada um dos quais tem uma localização e um valor particular. Esses elementos são
conhecidos como elementos de imagem, elementos da figura, pels ou pixels. Pixel é o termo
mais largamente utilizado para nomear os elementos de uma imagem digital
(GONZALEZ, 2002).
Como já visto, uma imagem é, essencialmente, um sinal no domínio do espaço, isto é,
representa a variação de intensidade de luz e de cor no espaço. Portanto, para que uma
imagem seja processada usando-se um sistema analógico unidimensional, ela geralmente é
convertida em um sinal no domínio do tempo, pelo uso de algum processo de varredura.
Contudo, para se processar uma imagem digitalmente, não é necessário realizar essa
conversão, pois ela pode ser processada diretamente no domínio espacial como uma matriz de
números. Isso dá ao processamento digital de imagens um enorme poder. No processamento
digital de imagens, a representação de sinais bidimensionais, a filtragem e as transformadas
desempenham um papel central (JAIN, 1989).
Dentro da área de processamento de sinais a manipulação de imagens digitais é um
processo cada vez mais utilizado e pesquisado. A manipulação de imagens é um processo que
pode ser decomposto em cinco estágios: geração, armazenamento, processamento,
transmissão e exibição (MARTINS, 1998). O processo de manipulação de imagens só se
15
tornou viável com o avanço das técnicas e processos para esse fim nos anos 70. Essas novas
tecnologias permitiram uma redução significativa no custo da manipulação e introduziram
novos dispositivos para exibição de imagens (OPPENHEIN, 1978).
Esta pesquisa trata especificamente da exibição de imagens digitais, que é a etapa
responsável por transformar uma imagem digital em uma aproximação de uma imagem
analógica a ser exibida. Como se sabe, a digitalização de uma imagem analógica consiste em
amostrá-la em ambas as coordenadas, x e y, e também em sua amplitude, para poder ser
digitalizada. A digitalização dos valores das coordenadas é chamada amostragem e a
digitalização dos valores da amplitude é chamado quantização. A qualidade de uma imagem
digital, portanto, é determinada principalmente pelo número de amostras e níveis de
intensidade utilizados nos processos de amostragem e quantização (GONZALEZ, 2002). No
momento da reconstrução, ou seja, da geração de uma imagem analógica a partir das amostras
da imagem digital, deve-se observar que os dispositivos de exibição de imagem são finitos e
isso faz com que a resolução máxima alcançada dependa da resolução dos mesmos. Dessa
forma, ao exibirem-se imagens digitais, deve-se ajustar sua resolução de acordo com o
dispositivo utilizado, bem como os requisitos de sua aplicação específica. Portanto,
interpolação de imagens é uma técnica importante para a aplicação de conversão de resolução
também chamada de reamostragem (resampling) (MORI, T., 2007). A interpolação de
imagens é utilizada atualmente em aplicações para fins de entretenimento e/ou profissionais
(MARSI, S., 1996). Como exemplos, podem ser citadas a conversão de imagens de TV com
resolução padrão para imagens a serem exibidas em dispositivos com alta definição (HDTV)
(MARSI, S., 1996), a geração de imagens médicas com fins de diagnóstico
(LEHMANN, T.M., 1999) ou simplesmente a aplicação de zoom em áreas de maior interesse,
a fim de observar detalhes da imagem (RODRIGUES, L., BORGES, D.L.,
GONÇALVES, L. M., 2002). Para a exibição de imagens existem vários dispositivos dentre
as quais destacam-se os que utilizam Tubo de Raios Catódicos (CRT), os displays de cristal
líquido (LCD) e as telas de plasma.
1.2. PROBLEMA MOTIVADOR
O problema motivador para este trabalho é a constatação de que atualmente existem
dois tipos de implementação de dispositivos interpoladores de imagens: aqueles
16
implementados em software e executados em hardware programável (HP), ou seja,
microprocessadores, e outros implementados diretamente em hardware fixo (HF). As
características de cada implementação devem ser analisadas sob o ponto de vista de sua
flexibilidade, desempenho e custo.
As implementações em software permitem uma grande flexibilidade, graças às
facilidades, inerentes aos programas, de alterar suas características funcionais. Essa solução,
entretanto, apresenta velocidade de processamento relativamente baixa e é relativamente
ineficiente, uma vez que o processador não será construído especificamente para o software
utilizado. Nesse aspecto, é importante ressaltar que baixos desempenhos implicam em atrasos
no processamento da imagem, os quais podem comprometer seriamente sua qualidade visual.
A segunda forma de implementação adotada é a utilização de filtros utilizando
hardware fixo. Essa implementação fornece alto desempenho relativo porque é personalizada
para o problema, é relativamente veloz na execução do processamento e possui custo de
implementação relativamente baixo. Contudo, apresentam pouca ou nenhuma flexibilidade
(DEHON, 1999) e a flexibilidade é uma característica muito importante na implementação
dos dispositivos interpoladores, uma vez que não existe um único tipo de interpolador que
apresente características ótimas para todas as aplicações em que seja necessária a exibição de
imagens. Portanto, caso a opção seja por dispositivos interpoladores em hardware fixo, pode
ser necessário um tipo de dispositivo específico para cada aplicação. Simples alterações em
suas características podem envolver um novo projeto, o que pode resultar em novo circuito.
Com base nessas observações, a grande questão é: que classe de implementação
escolher de modo a se beneficiar das vantagens das implementações em HP e HF e não sofrer
com suas desvantagens?
Esta dissertação propõe-se a apresentar uma solução possível, a qual consiste na
proposta e desenvolvimento da arquitetura de um circuito reconfigurável interpolador de
imagens digitais implementado em FPGA (Field Programmable Gate Array). Nesta pesquisa
serão utilizados conceitos de computação e arquitetura reconfigurável, para que seja possível
a reconfiguração do tipo de polinômio piecewise ou filtro de janelamento da função sinc a ser
utilizado, de acordo com os requisitos de cada aplicação.
Um FPGA é um complexo sistema construído em um chip que pode combinar
processadores, memória RAM, unidades lógicas aritméticas especializadas e obrigatoriamente
lógica reconfigurável. Quando um algoritmo é codificado utilizando recursos de hardware, o
FPGA pode processá-lo com uma velocidade 10 a 100 vezes maior que aquela obtida com
soluções em software (GOKHALE,2008).
17
1.3. OBJETIVOS
Para que o trabalho de pesquisa tenha êxito, apresentam-se a seguir o objetivo
principal a ser alcançado e alguns objetivos secundários também importantes, que deverão ser
atingidos durante o progresso da pesquisa.
O objetivo principal deste trabalho de pesquisa é propor e desenvolver uma arquitetura
de hardware reconfigurável e parametrizável para alterar a resolução de imagens digitais
monocromáticas através da interpolação. Para realizar a alteração da resolução ou realizar a
reamostragem serão utilizados polinômios ou filtros que utilizam uma janela na função sinc.
O desenvolvimento da arquitetura será feito utilizando VHDL e implementada em FPGA.
Essa arquitetura deve ser capaz de utilizar diferentes filtros ou polinômios para realizar a
alteração da resolução de imagens, com o compromisso de apresentarem boa qualidade, alto
desempenho e flexibilidade. A arquitetura também deverá ser independente da tecnologia
adotada em sua implementação.
Como objetivos secundários, destacam-se:
a) Estudo do estado da arte sobre alguns filtros de interpolação utilizados frequentemente,
tais como: Interpolador de ordem zero (Vizinho mais próximo), Interpolador de primeira
ordem (Linear) e filtro com janela de Lanczos;
b) Estudo do estado da arte sobre as técnicas de implementação de circuitos em FPGA
utilizando VHDL;
c) Verificação funcional da arquitetura proposta através da simulação VHDL;
d) Novas simulações, após a síntese em FPGA, para assegurar o correto funcionamento do
circuito proposto;
e) Realização de testes funcionais no hardware proposto utilizando análise subjetiva e
objetiva dos resultados alcançados com relação à qualidade das imagens interpoladas.
f) Implementação de um protótipo em FPGA que realize a interpolação de imagens digitais
de acordo com os objetivos propostos
18
1.4. METAS
A meta principal deste trabalho é a arquitetura de um circuito que seja reconfigurável
estaticamente para realizar a interpolação de imagens digitais. Para se chegar a essa meta
final, algumas metas secundárias deverão ser atingidas de forma a possibilitar o
desenvolvimento do circuito. Essas metas secundárias são listadas a seguir.
a) Arquitetura de hardware reconfigurável estaticamente, o que irá permitir a utilização de
diferentes polinômios ou filtros na reamostragem das imagens digitais;
b) Implementação da arquitetura em FPGA;
c) Obtenção de resultados na simulação VHDL;
d) Obtenção de um circuito que possa ser implementado em FPGA.
Portanto, a arquitetura do Circuito Interpolador de Imagens será a principal
contribuição deste trabalho.
1.5. JUSTIFICATIVA
Considerando o contexto, onde se mostrou o aumento acelerado da utilização de
imagens digitais nas mais diversas situações e, diante da necessidade de se realizar a
manipulação de imagens para adequá-la à sua aplicação, pode-se observar que esta pesquisa é
justificada pela importância da manipulação de imagens no mundo atual. Como também já
foi dito na Seção 1.2, soluções que realizam a reamostragem ou interpolação de imagens
deparam-se sempre com as alternativas de soluções flexíveis e relativamente lentas em
software, ou soluções com pouca ou nenhuma flexibilidade, mas com desempenho relativo
elevado. A alternativa a ser trabalhada nesta pesquisa propõe o desenvolvimento de uma
arquitetura de hardware reconfigurável que possa ser implementada em FPGA, o que busca
reunir as vantagens de desempenho e flexibilidade das implementações em software e em
hardware. Como base teórica desta pesquisa utilizam-se várias áreas de conhecimento, tais
como: processamento digital de sinais, processamento digital de imagens, projeto de sistemas
digitais, arquitetura de computadores e computação reconfigurável. Analisando-se pesquisas
que tratam de manipulação de imagens utilizando circuitos reconfiguráveis, verifica-se que
essa é uma área ainda recente, mas em grande expansão no mundo. Entretanto, quando se
19
buscam trabalhos de pesquisadores brasileiros, não se encontra uma grande quantidade de
publicações, apesar do crescente interesse pela área.
1.6. ESCOPO
Neste trabalho de pesquisa será proposta a arquitetura de um Circuito Interpolador de
Imagens digitais que seja reconfigurável e parametrizável, além de apresentar bom
desempenho relativo. Embora a implementação de um circuito em um tipo específico de
FPGA seja uma das metas da pesquisa, a arquitetura proposta deverá apresentar características
independentes do dispositivo adotado (fabricante, família, tecnologia eletrônica) e ainda ser
reconfigurável estaticamente. Portanto, o circuito será desenvolvido e testado utilizando uma
tecnologia específica, mas poderá ser também implementado utilizando outros dispositivos
equivalentes. Utilizaram-se nos testes várias classes de sinais: (i) sinais unidimensionais; (ii)
imagens ou segmentos de imagens estáticas e acromáticas, escolhidas dentre as figuras de
teste usualmente utilizadas na verificação de circuitos de processamento de imagens e (iii)
imagens sintéticas geradas pelo Matlab. Vale aqui ressaltar que tanto os sinais de entrada
quanto os de saída são discretos, compostos por número finito de pixels. Para análise dos
resultados utilizaram-se a análise subjetiva (inspeção visual) e a análise objetiva (métricas de
qualidade). A utilização da análise subjetiva justifica-se porque frequentemente a qualidade
percebida pelo sistema visual humano nem sempre está de acordo com os resultados de
qualidade obtidos com a análise objetiva, quando se comparam duas imagens interpoladas
(DODGSON,1997).
1.7. ORGANIZAÇÃO DO TEXTO
No Capítulo 2 desta dissertação, inicialmente, será apresentada uma revisão
bibliográfica dos principais conceitos de imagens, da teoria de reconstrução de sinais, da
utilização de filtros e polinômios para realizar a interpolação de pixels e dos princípios de
computação reconfigurável. Posteriormente será realizada uma apresentação sucinta sobre
FPGAs de dois principais fabricantes, Xilinx e Altera. Finalmente serão apresentados alguns
20
trabalhos correlatos que tratam de algoritmos ou da implementação de circuitos que realizam
a interpolação de pixels em imagens digitais, utilizando dispositivos lógicos programáveis e
computação reconfigurável.
No Capítulo 3, inicialmente, será proposta a arquitetura de hardware reconfigurável
e parametrizável para a interpolação de imagens digitais monocromáticas através da utilização
de polinômios ou de filtros que utilizam uma janela na função sinc. Inicialmente serão
apresentados os requisitos a serem atendidos por essa arquitetura e seu o diagrama em blocos,
mostrando cada uma das partes que a constituem. Por fim serão apresentados alguns trechos
da programação em VHDL e partes da estrutura do hardware gerado, além do mapa de
utilização de recursos em um FPGA da família Cyclone II do fabricante Altera.
No Capítulo 4 será apresentada a verificação funcional da arquitetura do circuito
interpolador de imagem. Inicialmente são apresentados os testes que verificaram o principal
bloco da arquitetura proposta, que é o Bloco de Processamento da Interpolação.
Posteriormente será realizada uma série de testes, utilizando todos os demais blocos da
arquitetura proposta, para interpolar uma única linha de imagem acromática gerada no
Matlab, cuja intensidade varia segundo uma função cosenoidal. Os resultados são
apresentados por meio de gráficos gerados no Matlab, o que permite uma análise visual
subjetiva, e também através de medições de MSE (Mean Square Error - Erro médio
quadrático) e de PSNR (Peak Signal to Noise Ratio - Relação pico sinal-ruído), o que
possibilita uma análise quantitativa.
No Capítulo 5 é apresentada a conclusão, que contém a discussão dos resultados
obtidos, comparando os possíveis ganhos alcançados com a utilização da arquitetura proposta
aos ganhos obtidos nos trabalhos relacionados. Nesse capítulo também é comentado o alcance
dos objetivos e das metas propostos nesta pesquisa. Em seguida, apresentam-se as principais
contribuições desta dissertação e, por fim, são listados alguns possíveis trabalhos futuros.
Finalmente são listadas as referências desta pesquisa.
21
2. REVISÃO BIBLIOGRÁFICA
Este capítulo será dividido em duas seções:
A primeira apresentará uma revisão teórica sobre conceitos fundamentais de
representação, digitalização e reconstrução de imagens, bem como de computação
reconfigurável, incluindo também um breve resumo sobre os FPGAs dos dois principais
fabricantes, Xilinx e Altera. Também serão mostrados alguns conceitos importantes sobre a
linguagem de programação VHDL.
Na segunda seção serão apresentados alguns trabalhos correlatos que tratam de
algoritmos ou da implementação de circuitos para a interpolação de pixels, utilizando
dispositivos lógicos programáveis e computação reconfigurável.
2.1. CONCEITOS TEÓRICOS
2.1.1. Representação de uma imagem digital
Imagens são uma distribuição espacial de irradiação no plano. Matematicamente
falando, a distribuição da irradiação espacial pode ser descrita como uma função E contínua
de duas coordenadas espaciais, x1 e x2, ou seja, E(x1,x2). Contudo, os processadores não
podem tratar valores contínuos, mas somente valores digitais, ou seja, discretos tanto no
domínio da amplitude, quanto no domínio da(s) coordenada(s) espaciais. Isso faz com que
seja necessário representar uma imagem como um conjunto de amostras discretas em
amplitude, em que o pixel representa a irradiação em uma determinada posição
(JÄHNE, 2002). Em uma abordagem mais simplificada, os pixels são localizados em uma
grade retangular, conforme a Figura 1.
Figura 1– Pixels distribuídos em uma grade retangular
Fonte: Elaborado pelo autor
22
A melhor maneira de definir a localização do pixel é por meio de matrizes
(JÄHNE, 2002) e, portanto uma imagem digital é representada pelas localizações dos pixels
em linhas e colunas de uma matriz. A Figura 2 ilustra uma matriz de N (linhas) por M
(colunas), portanto composta por N x M elementos.
Aqui é adequado apresentar a definição de pixels vizinhos na matriz. O conjunto de
pixels denominado “4 vizinhos de p”, em que p está localizado na posição (x,y), é formado
pelos pixels localizados nas coordenadas espaciais:
(x+1, y), (x-1,y), (x, y+1), (x, y-1)
Cada pixel vizinho fica a uma unidade de distância de (x,y), e alguns dos vizinhos de p
podem estar fora da imagem digital, quando p estiver localizado na borda dessa imagem.
(GONZALEZ, 2002).
Para que seja criada uma imagem digital, é necessário primeiramente capturar uma
imagem contínua utilizando algum dispositivo de captura de imagem, como uma câmera ou
um scanner. A seguir, é necessário converter o dado capturado para um formato digital
(GONZALEZ, 2002), o que envolve dois processos: amostragem (discretização das
coordenadas espaciais) e quantização (discretização da amplitude). A idéia básica por trás da
amostragem e da quantização é ilustrada na Figura 3. A Figura 3(a) mostra uma imagem
contínua, f(x,y). A função unidimensional mostrada na Figura 3(b) é um gráfico dos valores da
amplitude (níveis de cinza) do sinal contínuo ao longo do segmento AB da Figura 3(a). As
variações aleatórias são devido a ruído na imagem.
)1,1(..).........2,1()1,1()0,1(
)1,2(..).........2,2()1,2()0,2(
)1,1(..).........2,1()1,1()0,1(
)1,0(..).........2,0()1,0()0,0(
),(
MNfNfNfNf
Mffff
Mffff
Mffff
yxf
Figura 2 – Matriz com NxM elementos
Fonte: Elaborado pelo autor
23
Para amostrar essa função são tomados pontos igualmente espaçados ao longo da linha
AB, como mostrado na Figura 4(a). A localização de cada amostra é representada pelas
divisões no eixo localizado na parte inferior da figura e as amostras são exibidas como
pequenos quadrados brancos sobrepostos à função, na Figura 4(a). O conjunto desses pontos
discretos representa a função amostrada.
Entretanto, os valores das amostras ainda apresentam variação contínua dentro da
faixa de valores de cinza. Para converter esses valores para o formato digital, os níveis de
cinza também devem ser convertidos (quantizados) para valores discretos. Assim, o lado
direito da Figura 4(a) mostra a escala de cinza dividida em oito níveis discretos, variando do
Figura 4–Amostragem e quantização de uma linha e linha digitalizada
Fonte: GONZALEZ, 2002.
(a) (b)
Figura 3– Imagem contínua e amostragem de uma linha
Fonte: GONZALEZ, 2002.
(a) (b)
24
preto ao branco. As divisões do eixo vertical indicam o valor específico definido para cada
um dos oito níveis de cinza a serem utilizados para representar as amostras. A definição sobre
qual valor utilizar é feita considerando-se a proximidade vertical da amostra com a divisão da
escala. As amostras digitais resultantes dos processos de amostragem e quantização são
mostradas na Figura 4(b). Se esse processo for repetido linha a linha, igualmente espaçadas,
produz-se uma imagem digital em duas dimensões (GONZALEZ, 2002).
A definição sobre o tamanho da imagem (N x M) e sobre o número de níveis a ser
utilizado no processo de quantização não obedece a nenhum critério prévio, a não ser que
devem ser inteiros e positivos. Entretanto, devido a considerações de hardware nos processos
de amostragem, processamento e armazenamento, o número de níveis de cinza é, tipicamente,
um número inteiro potência de dois. Uma imagem com 256 níveis de cinza (28), possui
profundidade 8 e é chamada uma imagem de 8 bits. (GONZALEZ, 2002).
2.1.2. Interpolação e Reconstrução de imagens
Reconstrução de imagens é o processo de produzir uma superfície de intensidade
contínua a partir de uma imagem digital. O problema de reconstruir uma função definida
continuamente a partir de um conjunto de dados discretos é inevitável, sempre que alguém
necessita manipular dados utilizando informações não presentes de forma explícita
originalmente. Nos dias de hoje, em que se vê um aumento constante na digitalização de
dados e informações para facilitar o armazenamento, processamento, análise e transmissão da
informação, não é difícil encontrar exemplos de aplicação onde esse problema ocorra.
Existem duas grandes categorias de reconstrutores: os interpolantes e os aproximados.
Os interpolantes geram superfícies com intensidades que interceptam os valores dos pontos
amostrados; ao passe que os aproximados geram superfícies com valores de intensidade que
podem ou não interceptar os valores de intensidade dos pontos amostrados
(DODGSON, 1992).
A abordagem mais freqüentemente utilizada para tratá-lo é a utilização da
interpolação, onde uma função é utilizada a fim de complementar uma função discreta nos
pontos onde a informação não está presente (MEIJERING, 2002). Na literatura consultada, o
25
termo “interpolar” é freqüentemente utilizado com significado equivalente ao termo
“reconstruir”.
Desse modo, serão destacadas a seguir algumas definições do termo “interpolar”, que
ajudarão na compreensão deste trabalho:
a) Interpolar é predizer (ou estimar) o valor da variável em estudo num ponto não amostrado
(LANDIM, 2002);
b) A interpolação é um tipo de processamento de imagens que produz funções contínuas a
partir de pixels discretos (MORI, T., 2007).
Em (BURROUGH, 1986) comenta-se que as funções de interpolação podem ser
definidas como globais ou locais. A função global é dependente de todos os pontos
amostrados, sendo que a alteração de um valor de entrada afeta o mapa inteiro. As funções
locais são definidas para pequenas porções dos mapas, sendo aplicadas sucessivamente até
cobrir toda a área do mesmo. Uma alteração em um valor de entrada afeta apenas o resultado
de um subconjunto. Essas regiões podem ser definidas por raios de influência, ou por
quantidade de amostras vizinhas.
A função sinc, cuja expressão é dada na Equação 1, é uma função global que apresenta
a forma de onda ideal para interpolação no domínio espacial ou do tempo.
A Figura 5 mostra a forma de onda da função sinc.
sinc(x)=
1; para x=0
xoutroqualquerpara;x
xsin
(1)
26
O problema de utilizar essa função é que ela tem suporte infinito. Com isso ela não
pode ser utilizada em circuitos práticos, apesar de possibilitar a exata reconstrução da imagem
(MEIJERING , 1999). Uma alternativa para seu uso prático seria truncá-la. Contudo caso se
realize simplesmente o “truncamento” da função, os erros introduzidos na interpolação
poderiam resultar em uma imagem com distorções devido ao fenômeno de Gibbs
(MEIJERING, 2000). Distorções devido ao fenômeno de Gibbs causam a introdução de
artefatos com alta freqüência espacial (PRATT, 2001).
A fim de minimizar esse problema e obter-se uma reconstrução aceitável em termos de
custo computacional e precisão matemática, utilizam-se funções com suporte compacto que se
aproximem da função sinc tanto quanto possível. Várias funções implementando
aproximações da função sinc foram então desenvolvidas, o que deu origem aos polinômios
interpoladores piecewise de diversas ordens, como por exemplo, os de ordem zero, bi-linear,
quadrático e cúbico (MORI, T., 2007). Outra forma de se obterem aproximações da função
sinc é multiplicar a função sinc por uma função janela com suporte compacto. Várias janelas
são utilizadas dentre as quais podem ser citadas: Blackman, Hamming, Hanning, Retangular e
Lanczos (MEIJERING,1999, MICCAI, 1999). Nesse caso o valor do pixel interpolado
dependerá então diretamente do polinômio ou da janela utilizada (LANDIM, 2002).
Finalmente, o número de pixels interpolados entre dois pixels originais será utilizado
para definir o “Fator de Interpolação” utilizado neste trabalho. O Fator de Interpolação será
um parâmetro equivalente ao número de pixels interpolados acrescido de uma unidade.
Figura 5– Forma de onda da função sinc
Fonte: Elaborado pelo autor
27
2.1.3. Computação Reconfigurável
Computação reconfigurável é um modelo de computação importante para a
implementação de circuitos computacionais. Tradicionalmente têm sido realizadas
implementações de circuitos em hardware VLSI (Very Large Scale Integration)
customizados, ASICs (Application-Specific Integrated Circuits), em gate-arrays ou em
softwares para processadores DSPs – (Digital Signal Processors), para microcontroladores,
microprocessadores de propósito geral ou dedicados.
Recentemente, os FPGAs (Field Programmable Gate Array) introduziram uma nova
alternativa para a implementação de circuitos, utilizando características comuns às
implementações de hardware e em software. Sistemas implementados em FPGAs pretendem
aproximar-se do desempenho das soluções implementadas em hardware e/ou da flexibilidade
das soluções implementadas em software (MARTINS, 2003).
A implementação de circuitos em FPGAs levou a uma nova classe de implementação
de circuitos, chamada de circuito reconfigurável. Essas implementações têm como principais
características:
a) Poderem ser modificadas para resolver qualquer problema após a fabricação do circuito
(DEHON, 1999).
b) Serem altamente customizáveis pelo projetista em suas soluções. (DEHON, 1999).
Um Hardware reconfigurável baseado em FPGA possibilita a execução direta de um
algoritmo, uma vez que a lógica reprogramável pode ser reconfigurada um número ilimitado
de vezes, permitindo que um mesmo dispositivo execute diferentes algoritmos
(GOKHLE, 2008).
Os sistemas reconfiguráveis podem ser implementados somente em hardware
reconfigurável, mas podem ser híbridos, implementando parte da solução em hardware
reconfigurável e parte da solução através de software para hardware programável (por
exemplo, processadores ou hardware fixo não programável). Para que sejam desenvolvidas
soluções em hardware reconfigurável são freqüentemente utilizadas as linguagens de
descrição de hardware, como VHDL – (VHSIC - Very High Speed Integrated Circuits; HDL
- Hardware Description Language). Programas escritos nessas linguagens para FPGAs são
compilados usando-se uma ferramenta que gera os bits de configuração para um dispositivo
28
específico. VHDL é uma linguagem estruturada que oferece a possibilidade de descrever o
hardware, com a possibilidade de que ele seja simulado antes de sua síntese. Dessa forma, as
etapas de validação e verificação são facilitadas, tanto em termos de funcionamento, quanto
em termos de tempos de atraso dos componentes e desempenho, sem a necessidade da
prototipação inicial do hardware (MARTINS, 2003).
Conforme (CHEN, 2002) o maior limitador das implementações em software é que
elas geralmente levam muito tempo para serem processadas. Chen cita como exemplo uma
simulação de leitura em disco rígido, que implementada em software levaria alguns dias. Para
minimizar o tempo de processamento, Chen propõe a realização da implementação do
simulador de leitura em disco rígido utilizando um FPGA Xilinx Virtex E XCV-1000E. Nesse
trabalho ainda é reforçada a idéia de que a utilização de computação reconfigurável em FPGA
é a maneira de se melhorar o desempenho e a flexibilidade de um dispositivo, sem a
necessidade de se ter um “hardware duplicado”. Ele realiza duas formas de reconfiguração:
“reinicialização”, onde são redefinidos os conteúdos das look up table (LUT), e “re-
estruturação”, onde é redefinido o uso das estruturas do FPGA de forma a se conseguir um
melhor uso dos recursos.
A reconfiguração dos FPGAs também pode ser classificada como estática ou
dinâmica. Na reconfiguração estática, o dispositivo é reconfigurado antes de começar a
realizar o processamento dos dados. Nesse tipo de reconfiguração o dispositivo é
primeiramente configurado e mantém seu estado e funcionalidades enquanto essas
características sejam necessárias. Caso se necessite reconfigurá-lo para que realize outra
funcionalidade, o dispositivo deve parar de executar suas operações, ser reconfigurado e,
somente depois, retornado à atividade de computação para executar a nova seqüência de
operações (MARTINS, 2003).
Na reconfiguração dinâmica, por sua vez, o dispositivo não necessita ser parado para
que a nova configuração seja realizada. Ao contrário, realiza-se a reconfiguração apenas de
uma área que não esteja processando nenhum dado, simultaneamente à execução do
processamento. Esse tipo de reconfiguração também é conhecido como on-the-fly (HAUCK,
S.; DEHON, A., 2008).
29
2.1.4. Dispositivos reconfiguráveis
Um FPGA é um complexo sistema construído em um chip que pode combinar
processadores, memórias, unidade lógica aritmética e lógica reconfigurável
(GOKHLE, 2008). Diferentemente dos microprocessadores um FPGA não é programado com
um conjunto de instruções, mas com a descrição de uma arquitetura de hardware baseada em
componentes básicos. Atualmente dispositivos FPGAs com capacidade equivalente a milhões
de portas lógicas estão disponíveis (MAGANDA, 2005; XILINX, 2008; ALTERA, 2008 ).
A arquitetura de um FPGA varia de fabricante para fabricante, mas tipicamente possui
uma arquitetura interna composta de uma matriz de blocos lógicos configuráveis (CLB-
Configurable Logic Block) rodeado por uma rede de interconexão programável. Essa rede é
formada por blocos de interconexão. Ao redor de todo o circuito existem ainda os blocos de
entrada e saída (IOB- Input Output Block), que também são programáveis e servem como
interface entre a lógica interna do dispositivo e o mundo exterior (MARTINS, 2003).
A Figura 6 mostra a arquitetura de um FPGA da família Virtex II.
Como mostrado na Figura 6 o dispositivo possui blocos de entrada/saída (input/output-
IOB) e blocos lógicos configuráveis (Configurable Logic Blocks -CLBs).
A lógica interna configurável é composta por 4 grandes elementos:
Figura 6 – Arquitetura de um FPGA da família Virtex II
Fonte: Xilinx
30
a) Configurable Logic Blocks (CLB): fornecem os elementos funcionais para lógica síncrona
e combinacional, incluindo também elementos de armazenamento básicos.
b) Block SelectRAM: são módulos de memória fornecendo 18kbit de elementos de
armazenamento.
c) Multiplier: são multiplicadores dedicados de 18 bit x 18 bit.
d) Digital Clock Manager (DCM): Fornece calibração automática, soluções digitais para
compensação de atrasos (delay) na distribuição do sinal de relógio, multiplicação e divisão
do relógio e ajuste do deslocamento de fase do relógio.
Todos os elementos programáveis, incluindo os recursos de roteamento, são
controlados por valores armazenados em células de memória estática. Esses valores são
carregados nas células de memória durante a configuração e podem ser recarregados para
alterar as funções dos elementos programáveis.
Entre os dispositivos reconfiguráveis comerciais mais utilizados no mundo, destacam-
se os fabricados pelas empresas Xilinx (XILINX, 2008), Altera (ALTERA, 2008), Actel
(ACTEL,2008) e Atmel (ATMEL, 2007).
Como nesta pesquisa serão utilizados um FPGA da família Cyclone II da Altera e a
ferramenta de desenvolvimento Quartus II, disponível no laboratório LSDC do PPGEE, a
estrutura da família Cyclone será detalhada a fim de facilitar a compreensão da solução
proposta, que será apresentada no Capítulo 3.
Essa família de FPGAs foi produzida com vistas à rápida disponibilidade e ao baixo
custo, com base em informações e solicitações dos clientes da Altera. Ela é compatível com o
software Quartus II disponibilizado gratuitamente no site da Altera (www.altera.com).
Segundo informações da própria Altera, o baixo custo e o alto desempenho da família
Cyclone II tornam a sua escolha ideal em diversas aplicações, dentre as quais, o
processamento de imagens.
Sua arquitetura é bidimensional, baseada em linhas e colunas, e possui interconexões
entre blocos lógicos (LABs), blocos de memória e multiplicadores. Possui uma rede global de
relógio permitindo a utilização de até 4 PLLs (Phased Locked Loops). Esses PLLs permitem
uma grande flexibilidade na obtenção de sinais de relógio com freqüências múltiplas ou sub-
múltiplas da freqüência de um sinal original. Além disso, pode operar à freqüência máxima de
260MHz e possui blocos de memória M4K (dual-port, 260 MHz) com até 1,1 Mbits de RAM
disponível, sem redução da disponibilidade lógica. Uma característica interessante e que será
útil nesta pesquisa é a presença de 150 multiplicadores.
31
A Tabela 1 mostra uma comparação entre os diversos FPGAs da família Cyclone II,
destacando a coluna que mostra as características do dispositivo utilizado nesta pesquisa. São
apresentadas as seguintes características: quantidade de elementos lógicos LEs, blocos RAM,
total de bits da RAM, quantidade de multiplicadores internos e PLLs disponíveis em cada
dispositivo o que facilita a comparação entre eles.
Pode-se observar que o dispositivo EP2C5 é o que apresenta menor capacidade entre
todos dessa família, mas que possui os recursos necessários para o desenvolvimento desta
pesquisa.
A Figura 7 apresenta o mapa de distribuição, em que é mostrada a arquitetura com a
localização dos diversos elementos internos dos FPGAs da família Cyclone II.
O objetivo de mostrar esse mapa de distribuição é permitir localizar os diversos
elementos lógicos utilizados na implementação dentro do mapa de ocupação, que será
mostrado no Capítulo 3. O mapa de ocupação irá mostrar dentro do mapa de distribuição o
local onde se encontram os elementos lógicos utilizados no projeto permitindo uma análise
visual da ocupação dos mesmos.
Características da família de FPGA Cyclone II
Característica EP2C5 EP2C8 EP2C15 EP2C20 EP2C35 EP2C50 EP2C70
LEs 4608 8256 14448 18752 33216 50528 68416
Blocos RAM
M4K (4kbits
mais 512 bits de
paridade)
26 36 52 52 105 129 250
Total de bits da
RAM 119.808 165.888 239.616 239.616 483.840 594.432 1.152.000
Multiplicadores
internos 13 18 26 26 35 86 150
PLLs 2 2 4 4 4 4 4
Tabela 1 – Características da família de FPGA Cyclone II
Fonte: Altera
32
2.1.5. Linguagem de descrição de hardware – VHDL
A linguagem VHDL deve seu desenvolvimento à necessidade de uma
ferramenta de projeto e documentação para projeto VHSIC, do Departamento de Defesa dos
Estados Unidos na década de 1980. Ela é uma linguagem de descrição de hardware
padronizada, possibilita o intercâmbio de informações referentes ao comportamento de um
circuito entre fabricantes, fornecedores de sistemas e empresas de projetos (AMORE, 2005) .
As duas principais aplicações da VHDL estão relacionadas aos dispositivos lógicos
programáveis (incluindo FPGAs) e ASICs. A linguagem VHDL é adequada para
desenvolvimento e simulação de circuitos. Uma característica que diferencia as linguagens de
descrição de hardware das linguagens de programação seqüencial de computadores é que
nessas, as instruções são processadas seqüencialmente e naquelas, elas são processadas de
forma concorrente (paralela), com exceção de regiões específicas do código. Por isso a
linguagem VHDL é frequentemente chamada de código e não de programa
(PEDRONI, 2004).
Um código em VHDL pode ser escrito usando, basicamente, dois modelos de
descrição: estrutural e comportamental.A descrição estrutural informa a interligação dos
componentes, de forma a estabelecer uma hierarquia no projeto. A complexidade dessas
descrições pode ir de um simples registrador onde são informadas a entrada e a saída, a um
completo processador, contendo a interligação de blocos complexos como memórias,
unidades lógicas aritméticas etc (AMORE, 2005). Já no modelo comportamental, não é
Figura 7 – Arquitetura interna da família Cyclone II
Fonte: Altera
33
necessário descrever a organização física e topológica do sistema, mas somente o seu
comportamento. Um código que utiliza esse tipo de descrição possui o mesmo formato de um
programa fonte escrito em uma linguagem de programação de alto nível, como C++. Nesse
caso o projetista não necessita profundos conhecimentos de hardware. Geralmente a
possibilidade de mesclar esses dois modelos facilita o desenvolvimento de projetos mais
complexos (AMORE, 2005).
2.2. IMPLEMENTAÇÃO DE FILTROS DE INTERPOLAÇÃO DE IMAGENS UTILIZANDO
COMPUTAÇÃO RECONFIGURÁVEL
A seguir são apresentados alguns trabalhos que utilizaram computação reconfigurável
e/ou FPGA em circuitos que implementam sistemas para a interpolação de imagens.
Marsi (MARSI, 1996) apresenta um algoritmo para interpolação de imagens
preservando as bordas da figura. Sua abordagem baseia-se na observação de que qualquer
imagem no mundo real é derivada de uma imagem com mais alta resolução, sobre a qual se
aplica um filtro passa baixa e a seguir decimação. O filtro passa baixa tem o objetivo de evitar
o aliasing e a decimação, de reduzir a resolução da imagem. Quando uma borda está presente,
a operação de filtragem modifica os valores dos pixels adjacentes a ela de acordo com a
posição da borda na imagem de alta resolução. Com isso, após a decimação, os valores dos
pixels da imagem de baixa resolução carregam informação da posição da borda. Isso torna
possível realizar uma interpolação mais precisa do que uma simples interpolação linear.
Dessa forma, o algoritmo proposto por Marsi realiza uma média não linear dos pixels
adjacentes ao pixel a ser interpolado.
O algoritmo foi implementado em um circuito ASIC devido a limitações dos FPGAs
disponíveis à época. Inicialmente, para maior facilidade, foi descrito o hardware para o caso
unidimensional e depois apresentadas considerações para aplicações em duas dimensões.
O projeto privilegiou o tempo de processamento em relação ao custo final, uma vez
que as possíveis aplicações do algoritmo estão relacionadas à exibição de vídeos, o que
certamente exige alto desempenho.
Para simplificar o projeto e aumentar o desempenho do circuito, todas as operações
foram realizadas utilizando ponto fixo. Todas as entradas e saídas foram quantizadas, como
34
usualmente é feito, em 256 níveis de intensidade, usando barramentos de 8 bits para a
transmissão dos dados.
O resultado do trabalho foi um circuito de interpolação de imagens que apresentou
resultados superiores aos obtidos com técnicas convencionais tais como os interpoladores
lineares, uma vez que preserva as bordas na imagem interpolada. Foram mostrados os
resultados de simulações em uma e duas dimensões, bem como da implementação em
hardware.
Outro algoritmo para interpolação de imagens com a preservação de bordas,
adaptativo localmente, foi apresentado em (RODRIGUES,L., 2002). No trabalho é citada a
utilidade de aplicação do zoom em imagens, desde as utilizadas para entretenimento até as
utilizadas em análises científicas. Um problema mostrado é o fato de que, quando uma
imagem é interpolada, ela mantém suas características em baixas freqüências, mas atenua as
componentes de altas freqüências, devido ao comportamento dos interpoladores como filtros
passa baixa. O algoritmo proposto em (RODRIGUES,L., 2002) pretende minimizar os efeitos
dessa atenuação em altas freqüências, trabalhando de forma adaptativa localmente, utilizando
detecção de bordas através de análise matemática. Esse algoritmo foi proposto para escala de
cinza e fator de interpolação será sempre igual a 2. Os testes para demonstrar a eficiência do
algoritmo utilizaram a imagem de teste “Lena” e também uma imagem aérea. Foram
realizadas interpolações com técnicas de ordem zero até terceira ordem e os resultados foram
comparados com os obtidos com o algoritmo proposto. Como visualmente era difícil
quantificar as diferenças entre os métodos, foram calculadas a relação sinal ruído (SNR) e a
correlação cruzada entre a imagem original e as imagens interpoladas. Como conclusão final,
os resultados obtidos pelo método de interpolação adaptativo localmente (LAI) estão entre os
melhores no quesito “correlação cruzada”, sendo ainda mais simples de ser implementado e
menos complexo, segundo os autores, quando comparado aos métodos do vizinho mais
próximo, bi-linear, cúbico, cúbico B-spline e Linear. Esses métodos clássicos são detalhados
na literatura básica sobre processamento de imagens (PRATT, 2001 e GONZALEZ, 2002).
Outro trabalho correlato importante é o desenvolvimento da arquitetura de um circuito
reconstrutor de imagens digitais em tempo real que implementa a técnica de reconstrução de
imagens denominada “Reconstrutor Sinc Finito Amostrado Normalizado Bidimensional”
(RSFAN-2D) em (MARTINS, 1998).
Para a implementação foram realizadas algumas otimizações visando a aumentar a
velocidade de execução das operações. Por exemplo, a tarefa de interpolação foi
35
implementada em cinco estágios. O primeiro estágio realiza todas as multiplicações
necessárias em paralelo e os estágios seguintes implementam as etapas de adição. Os pixels
amostrados também foram armazenados, a fim de evitar a busca constante a esses pixels a
cada novo cálculo de pixels interpolados.
Analisando o circuito reconstrutor como uma caixa preta, observa-se que o fluxo de
dados na saída corresponde exatamente aos pixels da imagem reconstruída, que é formada
pelos pixels amostrados intercalados pelos pixels interpolados. Observa-se, portanto, que a
taxa de pixels reconstruídos na saída é maior que a taxa de pixels amostrados na entrada.
A arquitetura proposta para a operação de reconstrução de imagem possui três
estágios: estágio de armazenamento das amostras da imagem, estágio de interpolação e
estágio de multiplexação, que intercala pixels amostrados e pixels interpolados, de acordo
com o fator de interpolação escolhido, a fim de criar a imagem interpolada.
A arquitetura do circuito foi desenvolvida e implementada em dispositivos
programáveis ALTERA, com a síntese a partir da descrição em VHDL.
Toda a arquitetura proposta foi verificada a partir da implementação correta da técnica
RSFAN 2D. Os ganhos em termos de desempenho, quando comparados com a
implementação em software, também foram apresentados. Outra característica importante a
ser ressaltada é que as otimizações realizadas na arquitetura permitiram que a maior
complexidade computacional da técnica RSFAN 2D perdesse o seu impacto e permitisse a
implementação em tempo real, até mesmo para altas taxas de exibição.
Em (HUDSON, LEHN, ATHANAS, 1998), foi apresentado um dispositivo para
realizar a interpolação de imagens utilizando um dispositivo XC6264 da Xilinx. Esse trabalho
também realiza a interpolação de uma imagem introduzindo novos pixels entre os pixels
existentes, aumentando assim sua resolução. Para reduzir a complexidade computacional,
todas as operações de multiplicação e divisão são realizadas utilizando-se potência de 2, o que
é feito por simples e rápidas operações de deslocamento de bit. Todo o processo de
interpolação utiliza o princípio da separabilidade, onde primeiro é realizada a interpolação dos
pixels nas linhas e então, o resultado dessa interpolação unidimensional é utilizado para
realizar a interpolação dos pixels nas colunas. Ele cita ainda, como vantagem da
independência de cada linha em relação às demais, a possibilidade de ser utilizado o
paralelismo no processamento dessas operações. Para o projeto do dispositivo interpolador de
imagens foram utilizadas ferramentas de desenvolvimento disponíveis e familiares a ele. O
dispositivo desenvolvido permite quaduplicar a resolução de imagens de 128 x 128 pixels,
36
transformando-as em imagens de 512 x 512 pixels. A imagem original, que é carregada em
um bloco de memória disponível no FPGA utilizado, é lida e o resultado armazenado em
outro bloco de memória interno. A imagem final, após ser interpolada, é armazenada em um
bloco externo de memória. O tempo de processamento para a interpolação das linhas e
colunas é citado como dado importante no resultado final. Algumas reconfigurações
dinâmicas são realizadas pelo dispositivo proposto, reduzindo a utilização de recursos no
FPGA, mas introduzindo um atraso no processamento. Segundo os autores, a definição sobre
utilização de mais recursos ou menor tempo de processamento deve ser observada com
cuidado pelo projetista.
O trabalho (MAGANDA, 2005) propõe uma arquitetura em hardware para
implementação de uma interpolação bicúbica. A arquitetura proposta é aplicada a imagens
monocromáticas e é implementada em um FPGA da Xilinx Virtex-II Pro, codificado
utilizando linguagens VHDL e Handel-C. Foi também utilizada a ferramenta Xilinx ISE para
obter as estatísticas de consumo de recurso.
Nesse trabalho são mostradas as vantagens de se utilizar FPGA no lugar de
implementações em software, tendo sido comparados os desempenhos de algumas
implementações. Como uma das principais vantagens na utilização de circuitos
implementados em FPGA para processamento de imagens, são citadas a sua grande
flexibilidade e sua capacidade de possibilitar a implementação de estruturas paralelas de
processamento, o que aumenta muito o desempenho. O trabalho descreve o fato de que
existem inúmeras técnicas de interpolação que são utilizadas para aumentar ou diminuir o
tamanho de uma imagem, ressaltando as técnicas “Vizinho mais próximo”, bilinear e
bicúbica. Em sua implementação também foi utilizada a representação com ponto fixo. Foram
utilizadas imagens monocromáticas e nos cálculos se utilizaram multiplicadores internos do
FPGA escolhido. O tempo para execução da interpolação, no FPGA proposto, a uma
freqüência de 100MHz, foi 10 vezes menor que o tempo gasto na execução da interpolação
em software, utilizando-se um Pentium 4 a 2,4 GHz.
37
3. ARQUITETURA DE HARDWARE RECONFIGURÁVEL PARA UM CIRCUITO
INTERPOLADOR DE IMAGEM
Neste capítulo será apresentada uma arquitetura de hardware reconfigurável e
parametrizável para a interpolação de imagens digitais monocromáticas através da utilização
de aproximações da função sinc. Essas aproximações podem ser funções polinomiais
piecewise ou funções que criam uma janela na função sinc. Entretanto qualquer outro tipo de
interpolador baseado em coeficientes poderá ser utilizado. Inicialmente serão apresentados os
requisitos a serem atendidos por essa arquitetura. Em seguida serão mostradas, por meio de
diagramas em blocos, cada um dos blocos que compõem a arquitetura, com detalhamento das
soluções utilizadas em cada bloco. Por fim serão apresentados alguns trechos da programação
em VHDL e da implementação da arquitetura em FPGA, além do mapa de utilização de
recursos de um FPGA da família Cyclone II do fabricante Altera.
3.1. ANÁLISE DOS REQUISITOS A SEREM ATENDIDOS PELA ARQUITETURA PROPOSTA
O primeiro requisito funcional a ser atendido é a possibilidade de interpolação de
imagens monocromáticas estáticas, representadas com profundidade de oito bits por pixel,
utilizando diferentes polinômios piecewise ou filtros que criam uma janela na função sinc.
Analisando diversos trabalhos relacionados à interpolação (MEIJERING/NIESSEN, 1999),
(MEIJERING/KAREL, 1999), (SHAN CHAI, 2006) foi possível verificar que em todos eles
o grau máximo dos polinômios ou filtros utilizados é limitado, uma vez que podem existir
polinômios e filtros de qualquer grau. Vale ressaltar aqui que o grau ou a ordem de um
polinômio ou filtro é igual ao seu termo com mais alto grau. Decidiu-se, dessa forma, limitar
neste trabalho o grau máximo do polinômio ou filtro em três. Contudo, permanece aberta a
possibilidade de alterações futuras para que a arquitetura suporte graus maiores. A limitação
do grau máximo é necessária para definirem-se os recursos lógicos necessários, já que a
quantidade de pixels da imagem original a ser considerada na geração de um pixel interpolado
está diretamente relacionada com a limitação do grau máximo do polinômio ou filtro.
O segundo requisito funcional é que a utilização de filtros ou polinômios distintos não
pode implicar em uma alteração no hardware proposto. Ou seja, o hardware deve ser flexível
a fim de suportar alterações desse tipo, que podem abranger desde mudanças do polinômio ou
38
tipo de filtro a simples mudanças de grau, ou do fator de interpolação. Portanto, a solução irá
utilizar uma arquitetura de hardware reconfigurável estaticamente, de forma que o dispositivo
primeiramente seja configurado e então mantenha seu estado e funcionalidades, enquanto
essas características forem desejadas. Caso seja necessário reconfigurá-lo para a utilização de
outro polinômio ou tipo de filtro, ou para alterações do grau ou fator de interpolação, o
dispositivo deve parar de executar suas operações, a seguir ser reconfigurado e finalmente
retornar à atividade, executando a nova seqüência de operações. Aqui se optou por utilizar
polinômios de grau zero (Vizinho mais próximo) devido a sua simplicidade de implementação
(MEIJERING/NIESSEN, 1999), de primeiro grau (Linear) por ser o mais
utilizado(MEIJERING/NIESSEN, 1999) e um filtro de terceira ordem que utilize a janela de
Lanczos devido a disponibilidade dos coeficientes e por utilizar quatro pixels na construção
do pixels interpolado. A Equação 2 mostra o cálculo do pixel interpolado segundo Lanczos
O terceiro requisito é que a solução proposta seja independente do fabricante e da
tecnologia do dispositivo lógico programável. Para atender esse requisito, será utilizada na
descrição da arquitetura a linguagem VHDL padrão ou seja não serão utilizadas qualquer
instrução proprietária de algum fabricante. O motivo dessa escolha foi a flexibilidade
oferecida por essa linguagem na descrição do comportamento do hardware de circuitos
eletrônicos digitais. A linguagem suporta diferentes tipos de dados e permite estruturar o
projeto de tal forma que ele possa ser facilmente adaptado para outros ambientes de
desenvolvimento, independentemente da tecnologia e do dispositivo utilizado na
implementação.
3.2. ARQUITETURA PROPOSTA PARA O INTERPOLADOR
A Figura 8 apresenta a arquitetura de hardware proposta para o circuito interpolador
de imagem. Para a realização da interpolação bidimensional será utilizado o Princípio da
Separabilidade de forma que o processamento bidimensional seja desmembrado em dois
processamentos unidimensionais (DODGSON, 1992). Dessa forma, primeiro é realizada a
interpolação em cada uma das linhas (ou colunas). Em seguida, sobre a nova imagem já
interpolada em uma direção, é realizada a interpolação em cada um dos segmentos (colunas
)2()1()()1(
16
1
16
9
16
9
16
1ointerpoladPixel NNNN pppp (2)
39
ou linhas) na outra direção. Por utilizar menos hardware e aqui, simplificar muito o
processamento, esse método é utilizado em vários trabalhos correlatos, como, por exemplo
(MARSI, 1996), (LEHMANN, 1999) e (SHAN CHAI, 2006).
Na Figura 8, a imagem a ser interpolada é escrita diretamente no Bloco de Memória
endereçado pelo Bloco de Controle. O Bloco de Controle gera todos os sinais de controle e é
responsável pela parametrização da interpolação. Todos os parâmetros relacionadas ao
tamanho dos Blocos de Memória, tipo de coeficientes e fator de interpolação são aqui
inseridas. Aqui também são gerados os sinais que selecionam o Bloco de Memória e definem
o destino dos pixels interpolados para serem utilizados durante o processo de interpolação. O
Bloco de Gerenciamento dos Coeficientes é onde são inseridos todos os valores dos
coeficientes que serão utilizados no processo de interpolação. Podem-se inserir diversos
conjuntos de coeficientes, os quais serão selecionados através do fator de interpolação
inserido no Bloco de Controle. Poderão ser utilizadas N réplicas do conjunto: Blocos de
Memória, Mux de entrada, Blocos de Processamento da Interpolação e Demux de saída,
operando de diversas formas paralelas, caso um aumento do desempenho seja desejado.
Obviamente, isso levará ao aumento na utilização dos recursos lógicos a serem utilizados nas
implementações.
Bloco de Gerenciamento
dos Coeficientes Bloco de
Controle
Bloco de Processamento da
Interpolação
Bloco de
Processamento da
Interpolação
N x Blocos
Mux de
entrada
Mux de
entrada
x N
Demux
de saída
x N
Demux
de saída
Bloco de memória
Bloco de memória
x N Entrada
Saída
Figura 8 – Diagrama em blocos da arquitetura de hardware do circuito interpolador de imagens
Fonte: Elaborado pelo autor
40
A Figura 9 detalha o diagrama em blocos mostrado na Figura 8, evidenciando os
recursos lógicos para realizar a interpolação de uma imagem, no caso de N(número de
réplicas) igual a um. A interpolação de uma imagem, que é um procedimento bidimensional,
será desmembrada em dois processamentos unidimensionais: inicialmente será interpolada
cada uma de suas linhas, e depois, cada uma das colunas resultantes do processamento sobre
as linhas. O Bloco de Memória é composto pela Memória de Entrada e pela Memória
Intermediária. A primeira armazena a imagem a ser interpolada e a segunda armazena os
dados referentes ao resultado do primeiro processamento unidimensional (interpolação sobre
as linhas). No Bloco de Controle são inseridos todos os parâmetros que irão configurar o
circuito interpolador. O tamanho da Memória de Entrada será utilizado no cálculo do tamanho
da Memória Intermediária, que é utilizada como uma área onde os dados interpolados
horizontalmente são armazenados para serem interpolados verticalmente, de acordo com o
princípio da separabilidade. Essas informações serão utilizadas pelos contadores que
endereçam as memórias. Também é gerado o sinal que informa o tipo da operação no Bloco
de Memória: escrita (no caso de acesso à Memória Intermediária) ou leitura (no caso de
acesso à Memória de Entrada). Deve-se observar que o multiplexador colocado à saída do
Bloco de Memória irá selecionar a origem do pixel a ser interpolado (Memória de Entrada ou
Memória Intermediária, no caso de interpolação, respectivamente, de uma linha ou de uma
coluna). Para realizar corretamente a interpolação, o Bloco de Processamento da Interpolação
recebe do Bloco de Controle o sinal “Tamanho da linha” (ou da coluna) a ser interpolada.
Essa parametrização evita que o último pixel de cada linha (ou coluna) seja interpolado com o
primeiro pixel da linha (ou coluna) seguinte. Após o Bloco de Processamento da Interpolação
receber a informação de que o primeiro pixel lido da memória já está disponível para
processamento, através do sinal “Primeiro pixel da linha”, inicia-se o processo de interpolação
multiplicando os pixels vizinhos a ele pelos respectivos coeficientes. Esses coeficientes são
definidos de acordo com o polinômio ou filtro escolhido e também levam em consideração o
fator de interpolação. A escolha de outro conjunto de coeficientes implicará a necessidade de
se realizar uma reconfiguração estática do circuito interpolador no FPGA. Outro parâmetro a
ser informado ao circuito interpolador é o Fator de interpolação. Esse parâmetro é utilizado
pelo Bloco de Gerenciamento dos Coeficientes para selecionar o conjunto de coeficientes a
serem utilizados no cálculo dos pixels interpolados e também pelo Bloco de Controle para
calcular o tamanho da Memória Intermediária. O Bloco de Processamento da Interpolação
utiliza os coeficientes enviados pelo Bloco de Gerenciamento dos Coeficientes como pesos a
serem multiplicados pelos pixels vizinhos ao pixel amostrado. Finalmente há o
41
Demultiplexador de saída, que é controlado pelo sinal “Controle do Demux de saída”. O
Demux é responsável por direcionar o fluxo de pixels interpolados para a Memória
Intermediária ou para a saída do circuito de acordo com a fase do processo de interpolação.
42
Figura 9 – Diagrama em blocos da arquitetura do circuito interpolador
Fonte: Elaborado pelo autor
Bloco de Gerenciamento
dos Coeficientes
C_0
C_1
C_2
C_3
Pixels da imagem a
ser interpolada
Memória
Intermediária
Memória de
Entrada
Fator de
interpolação
Tamanho da
memória
intermediária
Tamanho da
linha ou da
coluna
Primeiro pixel da
linha
Leitura ou escrita
Endereçamento
Endereçamento
Mux da
memória
Multiplicador Somador
Bloco de Processamento
da Interpolação
Pixels da imagem
interpolada nas
linhas
Seleção da
memória
Bloco de Controle
Demux
de saída
Pixels da imagem
interpolada
Bloco de Memória
Controle do
Demux de saída
Tamanho da
memória de
entrada
43
3.2.1. Características da Arquitetura do interpolador
No escopo desta dissertação, serão desenvolvidos apenas os blocos responsáveis pelo
processamento unidimensional do processo de interpolação e utilizando N=1. Esses blocos,
que compõem a arquitetura do circuito interpolador de imagens, foram destacados em tons de
cinza na Figura 8. Esse recorte deve-se unicamente ao tempo disponível para a conclusão do
mestrado, sem prejuízo da verificação do circuito com relação à sua funcionalidade e ao
atendimento aos requisitos iniciais. Os demais blocos serão incorporados ao circuito
interpolador em trabalhos futuros. A arquitetura responsável pela interpolação unidimensional
é mostrada na Figura 10.
Observa-se que foram desenvolvidos e simulados em FPGA os seguintes blocos:
a) Bloco de Memória de Entrada,
b) Bloco de Controle,
c) Bloco de Gerenciamento dos Coeficientes,
d) Bloco de Processamento da Interpolação unidimensional.
C_0, C_1, C_2, C_3
Bloco de Gerenciamento dos
Coeficientes
Fator de
interpolação Tamanho da
memória
Tamanho
da linha ou
da coluna
Primeiro pixel da
linha
Bloco de Controle
Endereçamento
da memória
Bloco de memória
de Entrada
N x M
Multiplicador Somador
Bloco de Processamento da Interpolação unidimensional
Pixels da imagem
interpolada
Figura 10 – Diagrama em blocos da arquitetura do circuito interpolador
Fonte: Elaborado pelo autor
44
O Bloco de Memória de Entrada permite a inserção de imagens externas. Esse bloco
não é endereçado para escrita pelo Bloco de Controle, mas apenas para leitura. Ou seja, a
imagem já deve estar inserida na memória para que o circuito possa iniciar o seu
funcionamento.
O Bloco de Controle continua tendo a função de gerar todos os sinais de controle e,
nesta arquitetura para o processamento da interpolação unidimensional, ficou responsável por:
a) endereçar a memória de entrada para leitura dos pixels da imagem;
b) informar ao Bloco de Processamento da Interpolação o tamanho da linha ou da coluna;
c) informar ao Bloco de Processamento da Interpolação o instante em que o primeiro pixel
da linha está disponível para processamento, a fim de determinar o valor do pixel
interpolado;
d) informar ao Bloco de Gerenciamento dos Coeficientes o fator de interpolação.
No Bloco de Gerenciamento dos Coeficientes são inseridos os coeficientes de
diferentes polinômios ou filtros antes do início do processamento da mesma forma que a
imagem é inserida no Bloco de Memória de Entrada.
O último bloco desenvolvido e implementado é o Bloco de Processamento da
Interpolação. Esse bloco realiza as operações de multiplicação e soma necessárias para
calcular os pixels interpolados, alinhando-os para a criação do fluxo de dados seriais na saída.
Com a solução proposta, os pixels interpolados podem sofrer influência de até quatro
pixels vizinhos do mesmo segmento de imagem que pode ser linha ou coluna. Essa
quantidade é configurável por meio da utilização de coeficientes adequados, o que depende do
polinômio ou filtro escolhido. Definindo-se que a posição do pixel corrente seja representada
pela variável N, os quatro pixels vizinhos que podem ser considerados para realização da
interpolação são: p(N-1), p(N), p(N+1), p(N+2), ou seja um pixel antecessor (à esquerda) ao pixel
corrente p(N), o próprio pixel p(N) e dois pixels consecutivos (à direita) do pixel p(N). Um
polinômio ou filtro de primeiro grau utiliza dois pixels vizinhos para realizar a interpolação,
ou seja, os pixels utilizados são: p(N) e p(N+1). Um polinômio ou filtro de segundo grau utiliza
três pixels vizinhos para realizar a interpolação. Nessa implementação, os pixels utilizados
são: p(N-1), p(N) e p(N+1). Já um polinômio ou filtro de terceiro grau utiliza quatro pixels
próximos para realizar a interpolação cujas posições são: p(N-1), p(N), p(N+1) e p(N+2). Todos os
cálculos são realizados com a utilização de ponto fixo. Os valores dos multiplicadores que
45
irão definir o peso de cada pixel vizinho na construção do pixel interpolado serão
representados com 10 bits, pois são números inteiros variando entre -255, 0 e 256. Os valores
negativos justificam-se porque vários polinômios ou filtros que criam uma janela na função
sinc, mencionada no Capítulo 2, apresentam valores negativos. A inclusão do número 256,
que tornou obrigatória a inclusão de mais um bit, é necessária porque há pontos em que o
coeficiente vale 1. Deve-se ressaltar que o resultado final para o valor calculado do pixel
interpolado está entre 0 e 255, como é usual na representação de imagens monocromáticas,
com oito bits, para fins de observação pelo Sistema Visual Humano. O número de pixels
interpolados a serem inseridos entre dois pixels originais também pode variar entre um e três
pixels, dependendo do fator de interpolação. O tamanho dos segmentos de imagem a serem
interpolados também é um valor parametrizável através da entrada do tamanho da memória e
do tamanho das linhas da memória, que definirão, também, quantos segmentos
unidimensionais (linhas ou colunas) serão interpolados. Como o tempo de processamento está
diretamente ligado ao tamanho das imagens utilizadas, os testes apresentados nesta
dissertação utilizarão na maioria das vezes pequenas porções de imagens, que serão
interpoladas apenas em uma dimensão. A realização de testes com pequenos blocos de
imagens deve-se unicamente ao tempo disponível para a conclusão do projeto e em nada
restringe a sua utilização, ou mesmo altera a validade dos resultados obtidos.
3.2.2. Exemplo do processo de interpolação unidimensional
A Figura 11 mostra o processo de interpolação em um segmento linear de pixels. Entre
cada dois pixels no segmento original, pixel corrente p(N) e pixel consecutivo p(N+1), foi
introduzido um pixel interpolado, com valor igual à média entre os valores dos pixels p(N) e
p(N+1), a fim de que o tamanho do segmento original fosse duplicado. Não cabem aqui detalhes
sobre a forma como essa interpolação foi realizada, uma vez que o objetivo dessa ilustração é
apenas dar maior clareza ao processo e facilitar a compreensão futura do processo de
interpolação realizado pela arquitetura do hardware do circuito interpolador. Vale ressaltar
que, no fluxo de pixels do segmento de imagem interpolado, após o último pixel do segmento
original, devem ser inseridos um ou mais pixels interpolados, dependendo do fator de
interpolação pretendido. Para que isso seja possível são acrescentados pixels “estendido” após
46
o último pixel do segmento original. Na solução proposta, poderão ser utilizados nenhum, um
ou dois pixels “estendidos”, para fatores de interpolação iguais a 1, 2 ou 3, respectivamente.
No exemplo específico da Figura 11, como o fator de interpolação é dois (deseja-se duplicar o
número de pixels do segmento original), será acrescentado apenas um pixel “estendido”.
3.3. CODIFICAÇÃO DA ARQUITETURA EM VHDL
A linguagem escolhida para descrever, simular e sintetizar a arquitetura de hardware
proposta para o circuito reconfigurável de interpolação de imagens foi o VHDL. O motivo
dessa escolha foi a flexibilidade oferecida por essa linguagem na descrição do comportamento
de hardware de circuitos eletrônicos digitais, uma vez que suporta diferentes tipos de dados e
permite estruturar o projeto de tal forma que ele possa ser facilmente adaptado para outros
ambientes de desenvolvimento, independentemente da tecnologia, do fabricante e do
dispositivo utilizado na implementação. Além disso, a plataforma de desenvolvimento da
Altera tem a capacidade de simular o comportamento de um circuito sob teste com uma
ferramenta de simulação funcional, conhecida como Quartus II, o que possibilita testar
diversas situações antes do projeto final.
Neste trabalho, como o objetivo principal é a proposta de uma arquitetura de hardware
reconfigurável dedicada para a implementação de um circuito interpolador de imagem,
escolheu-se o modelo híbrido comportamental e estrutural, para a descrição do hardware em
VHDL. Também se tomou a precaução de utilizar somente as operações do VHDL que
pudessem ser sintetizadas, a fim de possibilitar sua implementação futura em circuitos reais.
A seguir serão mostrados alguns trechos da programação em VHDL dos blocos constituintes
da arquitetura apresentada na Figura 10.
0 50
0 0 50 Segmento original da imagem com 4 pixels
0 25
50
0
50
0
25
50
Fator de interpolação: 2
Segmento da imagem final, com os 4 pixels
originais e outros 4 interpolados
(O pixel central, em vermelho, não está
errado?
0 25
50
0
50
0
50
Figura 11 – Exemplo de interpolação em um pequeno segmento linear de imagem
Fonte: Elaborado pelo autor
47
3.3.1. Trecho da programação em VHDL do bloco de Gerenciamento de
coeficientes
A Figura 12 mostra um trecho do código em VHDL do Bloco de Gerenciamento dos
Coeficientes, instanciado como gen_coef_r00, com a definição de suas entradas e saídas. Aqui
se utiliza o sinal de reset geral (nrst) e os sinais utilizados para definir o fator de interpolação
(interp_r) e a posição dos pixels interpolados (pix_pos).
O Bloco de Gerenciamento dos Coeficientes gera como saídas os valores dos
coeficientes que serão utilizados na construção dos pixels interpolados. Considerando-se que
o pixel original corrente encontra-se na posição (N), os pixels originais que podem ser usados
para determinação dos pixels interpolados a serem inseridos entre o pixel original na posição
(N) e o pixel original na posição (N+1) são os pixels nas posições (N-1), (N), (N+1) e (N+2).
Dessa forma, são gerados como saída do Bloco de Gerenciamento dos Coeficientes os
seguintes sinais:
c_0 coeficiente que, no Bloco de Processamento da Interpolação, irá multiplicar o pixel na
posição (N+2),
c_1 coeficiente que, no Bloco de Processamento da Interpolação, irá multiplicar o pixel na
posição (N+1),
Figura 12 – Trecho em VHDL definindo as entradas e saídas do bloco gen_coef_r00.
Fonte: Elaborado pelo autor
ENTITY gen_coef_r00 IS
PORT( --Entradas:
clk_in : IN STD_LOGIC; --Clock
nrst : IN STD_LOGIC; --Reset ativo nível baixo
interp_r : IN INTEGER RANGE 1 TO 4; -- Fator de interpolação
pix_pos : IN INTEGER RANGE 0 TO 3; -- Posição do pixel (0..interp_r -1)
--Saídas
c_0 :OUT INTEGER RANGE -255 TO 256 --coeficiente 0 (256*coeficiente)
c_1 :OUT INTEGER RANGE -255 TO 256 --coeficiente 1 (256*coeficiente)
c_2 :OUT INTEGER RANGE -255 TO 256 --coeficiente 2 (256*coeficiente)
c_3 :OUT INTEGER RANGE -255 TO 256 --coeficiente 3 (256*coeficiente)
);
END gen_coef_r00;
48
c_2 coeficiente que, no Bloco de Processamento da Interpolação, irá multiplicar o pixel na
posição (N) e
c_3 coeficiente que, no Bloco de Processamento da Interpolação, irá multiplicar o pixel na
posição (N-1).
Poderão ser inseridos no Bloco de Gerenciamento dos Coeficientes todos os conjuntos
de coeficientes que possam ser utilizados pelo circuito interpolador, mantendo-se apenas um
dos conjuntos ativos e comentando-se as linhas referentes aos demais conjuntos. A seleção
dos coeficientes adequados é realizada no processo de reconfiguração estática realizado antes
do início do processo de interpolação.
3.3.2. Trecho da programação em VHDL definindo as constantes que irão gerar
os coeficientes de interpolação
A Figura 13 mostra um trecho do código em VHDL onde são inseridas as constantes
que serão iguais aos coeficientes para a interpolação linear (ou seja, de 1ª ordem), com o fator
de interpolação igual a dois, ou seja, após cada pixel original será inserido um pixel
interpolado a fim de duplicar o tamanho do segmento original.
Essas constantes serão utilizadas para calcular o peso da influência dos pixels vizinhos na
formação do pixel interpolado, de acordo com os coeficientes dos polinômios ou filtros
utilizados. Os índices utilizados na nomenclatura dessas constantes serão explicados a seguir.
---------constantes referentes aos coeficientes para interpolação com razão de interpolação
igual a 2 (Linear)
--------------------------------------------------------------------
CONSTANT c0_20 : INTEGER := 0;
CONSTANT c1_20 : INTEGER := 0;
CONSTANT c2_20 : INTEGER := 256;
CONSTANT c3_20 : INTEGER := 0;
CONSTANT c0_21 : INTEGER := 0;
CONSTANT c1_21 : INTEGER := 128;
CONSTANT c2_21 : INTEGER := 128;
CONSTANT c3_21 : INTEGER := 0;
Grupo 1: Coeficientes para a
repetição do pixel original na
posição (N)
Figura 13 – Trecho em VHDL definindo os valores das constantes do Bloco gen_coef_r00
para interpolação linear com fator de interpolação dois.
Fonte: Elaborado pelo autor
Grupo 2: Coeficientes para a
inserção do pixel interpolado,
calculado como a média entre os
pixels nas posições (N) e (N+1)
49
Os índices nas constantes utilizam o seguinte padrão: cA_BC
A: pode variar entre zero e três e refere-se à posição do pixel que será multiplicado pelo valor
do coeficiente de interpolação de acordo com a Tabela 2. Ressalte-se que N é a posição do
pixel original corrente.
B: refere-se ao fator de interpolação usado, podendo variar de um a quatro;
C: refere-se à posição onde será inserido o pixel interpolado que utilizar as constantes
definidas aqui. Seu valor pode variar de zero a três, sendo que zero sempre representa o pixel
original, que é repetido na imagem interpolada, e os demais valores representam os pixels
interpolados.
Os coeficientes utilizados para interpolação linear com fator de interpolação 2,
mostrados na Figura 13, são divididos em dois grupos: no primeiro grupo, apenas o
coeficiente c2_20, que tem valor igual a 256, irá contribuir para a determinação do pixel na
saída, uma vez que os outros tem valor igual a zero. Isso significa que o pixel (N) será
repetido na imagem interpolada, uma vez que no Bloco de Processamento da Interpolação,
que receberá como entradas os coeficientes c_0, c_1, c_2 e c_3, o valor calculado para o pixel
será ((256/256)*P(N)). O segundo grupo de coeficientes permitirá a inserção de um pixel
interpolado, cujo valor, calculado pelo Bloco de Processamento da Interpolação, será igual a
((128/256) * P(N) + (128/256) * P(N+1)). Nesse caso, como a interpolação é linear, o pixel
interpolado terá valor em escala de cinza igual à média dos valores dos pixels P(N) e P(N+1).
A Posição
0 N+2
1 N+1
2 N
3 N-1
Tabela 2 – Valores de A para definir a posição do pixel
Fonte: Elaborada pelo autor
50
3.3.3. Trecho da programação em VHDL para a geração do sinal d_ena pelo
bloco de Controle
Um trecho do código em VHDL que realiza a geração do sinal d_ena pelo Bloco de
Controle instanciado como add_cntr_r00 é mostrado na Figura 14. Esse sinal é utilizado pelo
Bloco de Processamento da Interpolação para o controle do fluxo de pixels e define o instante
onde será inserido o pixel original e os demais pixels interpolados. O sinal d_ena, informa ao
Bloco de Processamento da Interpolação, em lógica positiva, que um dado válido está
disponível e pronto para ser utilizado no processo. Nesse instante é repetido o pixel original.
Quando o sinal d_ena está em nível baixo é inserido um ou mais pixels interpolados, segundo
o fator de interpolação selecionado.
Observa-se que o duty cycle do sinal d_ena depende diretamente do fator de
interpolação, selecionado por meio do sinal interp_r. Aqui foi utilizado um contador auxiliar
chamado pix_pos_cnt, que vai contar de zero até o fator de interpolação menos 1, para variar
o duty cycle do sinal d_ena de acordo com a quantidade de pixels interpolados a serem
inseridos.
Figura 14 – Trecho em VHDL mostrando a geração do sinal d_ena. Fonte: Elaborado pelo autor
51
3.3.4. Trecho da programação em VHDL do bloco de processamento da
Interpolação
A Figura 15 mostra um trecho do código em VHDL do Bloco de Processamento da
Interpolação instanciado como gen_interp_r00, com a definição de suas entradas e saídas.
Nesse bloco, o sinal d_out corresponde à saída do fluxo de pixels do circuito
interpolador, em que estão presentes tanto os pixels originais quanto os pixels interpolados, já
inseridos corretamente em suas posições, de acordo com o fator de interpolação e utilizando-
se os polinômios ou filtros escolhidos.
3.4. PRINCIPAIS BLOCOS DA ARQUITETURA DO CIRCUITO INTERPOLADOR
A solução implementada em hardware para o circuito interpolador é apresentada a
seguir, detalhando-se cada um dos blocos sintetizados a partir da programação em VHDL e
terminando por mostrar a efetiva utilização de espaço e recursos no FPGA EP2C5F256C6 da
ENTITY gen_interp_r00 IS
PORT (
-- Entradas:
clk_in : IN STD_LOGIC; -- Clock
nrst : IN STD_LOGIC; -- Reset ativo em nível baixo
d_in : IN INTEGER RANGE 0 TO 255; -- Entrada de pixels
d_ena : IN STD_LOGIC; -- Habilitação para novo dado
first_pix : IN STD_LOGIC; -- Identifica o primeiro pixel da linha
c_0 : IN INTEGER RANGE -255 TO 256; --coeficiente 0 Posição(N+2)
c_1 : IN INTEGER RANGE -255 TO 256; --coeficiente 1 Posição(N+1)
c_2 : IN INTEGER RANGE -255 TO 256; --coeficiente 2 Posição(N)
c_3 : IN INTEGER RANGE -255 TO 256; --coeficiente 3 Posição(N-1)
-- Saídas:
d_out : OUT INTEGER RANGE 0 TO 255 -- Saída de pixels da imagem
--reconstruída incluindo a copia dos pixels originais e a inserção dos
--interpolados
);
END gen_interp_r00;
-------------------------------------------------------------------------
Figura 15 – Trecho em VHDL definindo as entrada e saídas do Bloco gen_interp_r00. Fonte: Elaborado pelo autor
52
família Cyclone da Altera, disponível para uso no LSDC do Programa de Pós Graduação em
Engenharia Elétrica da PUC-Minas (PPGEE).
O FPGA escolhido para implementação da arquitetura do circuito interpolador de
imagem foi o EP2C5F256C6 da família Cyclone II da Altera. O dispositivo EP2C5F256C6 é
o mais simples da família Cyclone II e foi escolhido devido à presença de multiplicadores e
memória interna, além de estar disponível no laboratório do PPGEE.
3.4.1. Bloco de memória de entrada
A Figura 16 mostra a representação do Bloco de Memória de Entrada instanciado,
onde fica armazenada a imagem a ser interpolada. São parâmetros dessa arquitetura o
tamanho total da imagem (linhas x colunas) e o tamanho das linhas. No presente caso, trata-se
de um segmento linear com 64 pixels, representados em níveis de cinza com oito bits cada.
A delimitação do tamanho de cada linha da imagem é um parâmetro configurável no
Bloco de Controle do interpolador, mostrado mais à frente no item 3.4.3. Nos testes
apresentados nesta dissertação, serão utilizados como entradas sinais unidimensionais de até
512 colunas ou sinais bidimensionais com até 256 linhas e no mínimo 8 colunas (pixels).
Contudo, em qualquer situação, a imagem original será interpolada em uma única direção, a
cada vez, já que se trata da implementação da arquitetura do circuito interpolador
unidimensional.
3.4.2. Bloco de gerenciamento dos coeficientes
A Figura 17 mostra o Bloco de Gerenciamento dos coeficientes, instanciado como
gen_coef_r00 .
8 b
its
64
wo
rds
Block type: AUTO
address[5..0]
clock
q[7..0]
pix_in_mem
inst4
Figura 16 – Bloco de Memória de Entrada que armazena a imagem a ser interpolada
Fonte: Elaborado pelo autor
53
O Bloco de Gerenciamento dos Coeficientes tem uma função extremamente
importante na arquitetura aqui proposta. É nele que são inseridas as constantes referentes aos
coeficientes que serão utilizados para o cálculo dos pixels interpolados.
Os valores dessas constantes, como detalhado no item 3.3.2, são iguais aos valores dos
coeficientes dos polinômios ou filtros, que variam em módulo entre 0 e 1, multiplicados por
256 e arredondados para o inteiro mais próximo. Isso foi necessário porque todos os cálculos
são realizados com inteiros e ponto fixo. Para todas as situações, ou seja, independente da
ordem do polinômio, o Bloco de Gerenciamento dos Coeficientes gera como saídas quatro
coeficientes (c_0, c_1, c_2 e c_3), disponibilizando-os simultaneamente ao Bloco de
Processamento da Interpolação. Sendo assim, nos casos em que nem todos os coeficientes
seriam necessários, como nos processos de interpolação de ordem zero, de primeira ou de
segunda ordem, para os quais seriam usados apenas um, dois ou três coeficientes,
respectivamente, os outros coeficientes deverão ser carregados com valor zero. A
representação dos coeficientes utiliza 10 bits porque a faixa de valores possíveis são números
inteiros que vão de -255 a 256. Foi prevista essa ampla faixa de coeficientes porque valores
negativos são comuns em funções de interpolação polinomiais piecewise ou filtros que criam
uma janela na função sinc. Dessa forma, a princípio não será necessário prever qual função
polinomial ou filtro será utilizado. Contudo, a faixa de valores dos coeficientes pode ser
reduzida caso exista interesse em definir previamente os polinômios ou filtros que criam uma
janela na função sinc. Deve-se lembrar de que a soma dos valores dos pixels vizinhos
multiplicados por seu respectivo peso na construção do pixel interpolado nunca ultrapassa
255, que é o valor máximo da profundidade dos tons de cinza utilizado neste trabalho.
Entretanto, como na arquitetura proposta utiliza-se ponto fixo e os coeficientes nem sempre
são números inteiros, pode ocorrer que o valor do pixel interpolado ultrapasse ligeiramente
255 ou fique menor do que zero. Essa condição foi prevista e por isso foi inserida uma
limitação dos valores máximo e mínimo possíveis para os pixels interpolados.
clk_in
nrst
interp_r[2..0]
pix_pos[1..0]
c_0[9..0]
c_1[9..0]
c_2[9..0]
c_3[9..0]
gen_coef_r00
inst1
Figura 17– Bloco de Gerenciamento dos coeficientes
Fonte: Elaborado pelo autor
54
Existem ainda outras duas entradas no Bloco de Gerenciamento dos Coeficientes que
merecem destaque: interp_r e pix_pos. É através da entrada interp_r que o bloco é informado
sobre o fator de interpolação pretendido, o qual pode variar de um a quatro, correspondendo à
inserção, respectivamente, de zero a três pixels interpolados entre cada dois pixels do
segmento original. Parece estranho o fator de interpolação poder ter valor igual à unidade,
mas a repetição dos pixels originais sem a inserção de pixels interpolados foi um teste
importante no desenvolvimento da temporização do projeto, tendo sido mantida. A entrada
pix_pos, por sua vez, serve para alinhar corretamente os coeficientes que serão utilizados no
processo de geração dos pixels interpolados.
3.4.3. Bloco de controle
A Figura 18 mostra o Bloco de Controle instanciado como add_cntrl_r00, utilizado
para o controle geral do interpolador.
O Bloco de Controle também necessita da informação relativa ao fator de
interpolação, que é informado através do sinal interp_r. Como o tamanho da imagem pode ser
variável, existe aqui a possibilidade de se informar o tamanho da memória onde se encontra a
imagem a ser interpolada, utilizando-se o sinal rd_mem_size. Esse dado é utilizado para gerar
o sinal rd_add(X..0), que tem por objetivo controlar o endereçamento do Bloco de Memória
de Entrada. No Bloco de Controle mostrado na Figura 18 a memória está definida para ter 64
posições, as quais são endereçadas pelo vetor de bits rd_add(5..0). Contudo, esse parâmetro
pode ser alterado para atender à especificação definida anteriormente, de que a arquitetura
possa implementar a interpolação sobre uma imagem de tamanho variável. Outro parâmetro
configurável é o tamanho das linhas do Bloco de Memória de Entrada através do sinal
lin_mem_size. Aqui é possível definir o formato do Bloco de Memória de Entrada com
diferentes configurações de linhas e colunas. No Bloco de Controle mostrado na Figura 18, o
Figura 18 – Bloco que gera todos os sinais de controle do interpolador
Fonte: Elaborado pelo autor
clk_in nrst interp_r[2..0] rd_mem_size[6..0] lin_mem_size[6..0]
rd_add[5..0]
pix_pos[1..0] d_ena
first_pix
add_cntrl_r00
inst
55
tamanho máximo da linha é de 128 colunas porque utiliza um vetor de 7 bits, mas esse valor
pode ser reconfigurado. Apesar do nome lin_mem_size, ele também pode servir para informar
o tamanho das colunas, no caso do processamento da interpolação no sentido vertical. A saída
pix_pos serve para temporizar corretamente os coeficientes que serão utilizados no processo
de geração dos pixels interpolados, como descrito no Bloco de Gerenciamento dos
Coeficientes, mostrado no item 3.4.2. A saída first_pix é utilizada para informar ao Bloco de
Processamento da Interpolação, que o pixel que está sendo disponibilizado para
processamento corresponde ao primeiro pixel da linha. Esse sinal evita que o último pixel de
determinada linha seja interpolado com o primeiro pixel da linha seguinte, já que a memória
armazena os valores dos pixels em posições contíguas, uma vez que não há divisões entre
linhas e colunas, como habitualmente a imagem é representada. Por último, o Bloco de
Controle gera o sinal d_ena, que informa ao Bloco de Processamento da Interpolação, em
lógica positiva, que um dado válido está disponível e pronto para ser utilizado no processo.
3.4.4. Bloco de processamento da interpolação
A Figura 19 mostra o Bloco de Processamento da Interpolação, instanciado como
gen_interp_r00, que é o bloco que realiza efetivamente a interpolação e gera o fluxo de pixels
da imagem com maior resolução a partir do processo de interpolação.
Esse bloco utiliza como entradas todos os sinais de controle e variáveis que foram
gerados anteriormente nos blocos mostrados nas seções 3.4.1 a 3.4.3. Os pixels vindos do
Bloco de Memória de Entrada entram nesse bloco através de um barramento de oito bits
clk_in nrst d_in[7..0] d_ena first_pix c_0[9..0] c_1[9..0] c_2[9..0] c_3[9..0]
d_out[7..0]
gen_interp_r00
inst
Figura 19 – Bloco que realiza a interpolação e gera o fluxo de pixels à saída do
interpolador
Fonte: Elaborado pelo autor
56
d_in(7..0). A quantidade de pixels interpolados a serem calculados depende do fator de
interpolação e é controlado pelo sinal d_ena no Bloco de Processamento da Interpolação. A
variação do duty dycle do sinal d_ena é que irá controlar a inserção de pixels originais e pixels
interpolados em sua posição correta. O sinal first_pix vindo do Bloco de Controle informa o
instante exato da disponibilização do primeiro pixel da linha ou coluna da imagem para o
processamento da interpolação. Como já foi mencionado, isso evita a interpolação do último
pixel de uma linha ou coluna com o primeiro da linha ou coluna seguinte. De acordo com o
polinômio ou filtro escolhido, os pixels recebidos do Bloco de Memória de Entrada são
multiplicados pelos coeficientes recebidos do Bloco de Gerenciamento dos Coeficientes. Os
resultados desses produtos, que refletem a contribuição de cada pixel vizinho para a
determinação do pixel interpolado, são então somados e o resultado dividido por 256 para
produção do valor do pixel interpolado. Um diagrama representando esse processo é mostrado
na Figura 20.
A saída do Bloco de Processamento da Interpolação é um fluxo de pixels seqüencial
(d_out), composto pelos valores dos pixels originais intercalados pelos valores dos pixels
interpolados, de acordo com o fator de interpolação e o polinômio ou filtro utilizado.
Pixels da imagem armazenada na
memória de entrada
Multiplicação pelos
coeficientes
p(N-1)* C_3 p (N) * C_2 p(N+1) * C_1
p(N+2).* C_0
C_3 C_2 C_1 C_0
Coeficientes
[p(N-1)* C_3 + p (N) * C_2 + p(N+1) * C_1 + p(N+2).* C_0]/256
Soma dos resultados das multiplicações
Pixels da imagem
interpolada
Figura 20 – Diagrama em blocos da geração dos pixels interpolados
Fonte: Elaborado pelo autor
57
3.5. IMPLEMENTAÇÃO DA ARQUITETURA (CODIFICADA EM VHDL) NO FPGA
EP2C5F256C6
A implementação da arquitetura proposta é baseada na utilização de dispositivos
lógicos reconfiguráveis do tipo FPGAs uma vez que demanda reconfiguração após a
fabricação do dispositivo e também flexibilidade. Esses dispositivos lógicos reconfiguráveis
oferecem desempenho comparável com o oferecido por dispositivos de propósito específico
(Application Specific Integrated Circuit - ASIC), integração de mais funções, tal como
processador e memória, reduzido consumo de potência e custos competitivos (MARTINS,C.
A. P. S. 2003).
O FPGA escolhido para implementação da arquitetura do circuito interpolador de
imagem foi o EP2C5F256C6 da família Cyclone II da Altera. O dispositivo EP2C5F256C6 é
o mais simples da família Cyclone II e foi escolhido devido à presença de multiplicadores e
memória interna, além de estar disponível no laboratório do PPGEE.
A família Cyclone II é a evolução da família Cyclone com mais elementos lógicos, mais pinos
de entrada e saída e mais memória mantendo, entretanto preços bastante competitivos com
outros fabricantes. Além disso, seu consumo de potência foi mantido baixo apesar do
aumento de desempenho. Ele possui 4096 elementos lógicos, 119.808 bits de memória RAM,
13 multiplicadores e 2 PLLs.
É mostrado na Figura 21 o mapa de ocupação do FPGA EP2C5F256C6 da família Cyclone da
Altera, quando configurado para realizar o processamento unidimensional da interpolação
sobre uma imagem com 512 bits e fator de interpolação igual a 2. Verifica-se que a área
ocupada é relativamente baixa comparada à quantidade de recursos lógicos disponíveis.
Figura 21 – Mapa de ocupação no dispositivo da família Cyclone II utilizado
Fonte: Elaborado pelo autor
58
O quadro 1 mostra de maneira quantitativa os recursos efetivamente utilizados no
dispositivo EP2C5F256C6 da família Cyclone da Altera.
Verifica-se aqui, de forma quantitativa, que a utilização de recursos foi muito baixa,
como havia sido constatado visualmente no mapa de ocupação do dispositivo. Um detalhe a
ser ressaltado é que o relatório de compilação, mostrado no Quadro 1, menciona 26
multiplicadores, enquanto havia sido dito anteriormente que este FPGA possuía 13
multiplicadores. A justificativa para isso é que a tabela de ocupação mostra multiplicadores de
9 bits e os multiplicadores citados na documentação do dispositivo referem-se a
multiplicadores de 18 bits. Apesar da pouca ocupação de recursos lógicos, utilizou-se mais da
metade do total de pinos disponíveis. A memória utilizada no exemplo acima representa o
tamanho da imagem de entrada e foi de apenas 512 bits correspondendo a 64 pixels.
Entretanto, um aumento do tamanho da memória pode ser implementado até a capacidade
máxima do dispositivo. Novamente deve-se ressaltar que um dos principais motivos que
justificam a utilização desse dispositivo é a sua existência nos laboratórios do PPGEE, o que
viabilizará desenvolvimentos futuros.
Flow Status Successful - Wed Nov 05 10:13:56 2008
Quartus II Version 8.0 Build 231 07/10/2008 SP 1 SJ Web
Edition
Revision Name interp_1d
Top-level Entity Name interp_1d
Family Cyclone II
Met timing requirements Yes
Total logic elements 177 / 4,608 ( 4 % )
Total combinational functions 144 / 4,608 ( 3 % )
Dedicated logic registers 77 / 4,608 ( 2 % )
Total registers 77
Total pins 86 / 158 ( 54 % )
Total virtual pins 0
Total memory bits 512 / 119,808 ( < 1 % )
Embedded Multiplier 9-bit elements 4 / 26 ( 15 % )
Total PLLs 0 / 2 ( 0 % )
Device EP2C5F256C6
Timing Models Final
Quadro 1 – Recursos utilizados no dispositivo da família Cyclone
Fonte: Elaborado pelo autor
59
4. RESULTADOS
Neste capítulo é apresentada a verificação funcional e de qualidade da imagem
interpolada da arquitetura do circuito interpolador de imagem proposta no Capítulo 3. Na
Seção 4.1 são apresentados os testes que verificaram o principal bloco da arquitetura proposta
na Seção 3.2.1 que é o Bloco de Processamento da Interpolação. Em um primeiro momento
esse bloco foi verificado isoladamente dos demais blocos da arquitetura apresentada na
Figura 10, utilizando-se um interpolador linear com fatores de interpolação iguais a dois e
três, correspondendo, respectivamente, à inserção de um e dois pixels interpolados entre dois
pixels originais consecutivos.
Na seção 4.2 é apresentada uma série de testes, utilizando todos os demais blocos da
Figura 10, para realizar a interpolação em uma única linha de uma imagem acromática gerada
sinteticamente no Matlab, com variações dos tons de cinza seguindo uma função cossenoidal
de baixa freqüência e, posteriormente, de alta frequência. São mostrados os resultados obtidos
em interpolações de ordem zero (vizinho mais próximo), de primeira ordem (linear) e de
terceira ordem (Lanczos). Esses resultados são apresentados por meio de gráficos gerados no
Matlab, o que permite uma análise visual subjetiva, e também através de medições dos
parâmetros MSE (Mean Square Error) e PSNR (Peak to Signal Noise Ratio), o que possibilita
também uma análise quantitativa. Na primeira fase dos testes, utilizou-se fator de interpolação
igual a dois e, posteriormente, apenas para os coeficientes de Lanczos, foram obtidos
resultados com fator de interpolação igual a quatro.
Por último, foram realizados testes com a imagem real “Fishing Boat”, que é uma das
imagens normalmente utilizadas em trabalhos relacionados a processamento de imagens,
cujos resultados são mostrados na Seção 4.3. Esses testes foram separados em duas fases. A
primeira fase realizou a interpolação bidimensional, com fator de interpolação igual a dois,
sobre uma região da imagem “Fishing Boat”, com dimensão igual a 64 x 16 pixels. Nesse
caso, como a arquitetura proposta para a interpolação bidimensional apresentada na Figura 8
foi implementada somente para N=1 e para uma dimensão, utilizou-se a arquitetura
implementada para a interpolação unidimensional, apresentada na Figura 10, duas vezes
consecutivas: inicialmente para realizar a interpolação sobre as linhas e depois, para realizar a
interpolação sobre as colunas da imagem resultante da interpolação no sentido horizontal. Na
60
Figura 22 – Diagrama temporal do Bloco de Processamento da Interpolação
utilizando interpolação linear com fator de interpolação igual a dois
Fonte: Elaborado pelo autor
segunda fase dos testes com a imagem “Fishing Boat”, foi realizado um teste da interpolação
linear sobre todas as colunas da imagem.
O objetivo foi aumentar a resolução da imagem, originalmente com 256 x 128 pixels para
uma imagem com 256 x 256 pixels. Esse teste comparou de forma quantitativa os resultados
obtidos na Matlab e aqueles obtidos na simulação do circuito interpolador de imagens.
4.1. TESTES FUNCIONAIS DO BLOCO DE PROCESSAMENTO DA INTERPOLAÇÃO
Os resultados dos testes realizados serão mostrados através do diagrama de simulação
temporal produzido com o ambiente de desenvolvimento Quartus II da Altera, apresentados
nas Figuras 22 e 24.
Como mencionado, na primeira fase dos testes, o Bloco de Processamento da
Interpolação foi verificado isoladamente dos demais blocos componentes da arquitetura. O
principal objetivo foi verificar a estrutura que seria responsável por realizar a interpolação
propriamente dita. Sendo assim, os sinais de entrada, compostos pelos sinais de controle
d_ena e first_pix (Primeiro pixel da linha), os valores dos pixels de entrada d_in e os valores
das constantes c_0, c_1, c_2 e c_3, coeficientes do polinômio, que serão utilizadas para
calcular os pesos a serem atribuídos aos pixels das posições (N+2), (N+1), (N) e (N-1),
respectivamente, foram inseridos diretamente no simulador. Ressalta-se que os valores dos
pesos equivalem aos valores dos coeficientes divididos por 256. O fator de interpolação, por
sua vez, é informado indiretamente ao Bloco de Processamento da Interpolação através do
duty cycle do sinal de controle d-ena. Considerando a definição de duty cycle de um sinal
61
como sendo a razão entre o instante de tempo em que o sinal permanece em nível lógico alto
durante um período completo e o período do sinal (SEDRA, 2007) definiu-se que se o duty
cycle do sinal d_ena for 50%, 33% ou 25% indicará, respectivamente a utilização de fator de
interpolação igual a 2, 3 ou 4.
Na Figura 22, por exemplo, o duty cycle do sinal d_ena foi de 50% e, portanto, o fator
de interpolação usado foi igual a 2. É necessário observar que os valores instantâneos dos
coeficientes variam segundo o código VHDL da Figura 13.
Conforme se observa na Figura 22, os primeiros testes utilizaram uma seqüência de
linhas de entrada com sete valores de pixels: 60, 90, 120, 150, 180, 150, 120. O sinal de
controle first_pix, quando em nível alto, identifica que o primeiro pixel da linha está
disponível para processamento. Cada linha foi interpolada utilizando-se um interpolador
linear (o que é determinado pelos coeficientes de entrada c_0, c_1, c_2 e c_3) com fator de
interpolação igual a dois (uma vez que o duty-cycle do sinal d_ena é de 50%). Sendo assim, o
fluxo de pixels de saída, mostrado no vetor d-out, corresponde à cópia de cada pixel do sinal
original (localizado na posição (N)), seguido do pixel interpolado (média entre os dados das
posições (N) e (N+1)), para 1 N tamanho da linha. Os valores que representam os pixels da
imagem interpolada começam a ficar disponíveis na saída d_out, seis ciclos de clock após a
identificação do primeiro pixel da linha. Ou seja, o circuito interpolador apresenta uma
latência de seis períodos de clock. A verificação funcional do Bloco de Processamento da
Interpolação mostrou que a seqüência de pixels de saída foi coerente com a seqüência de
pixels de entrada, interpolada através da interpolação linear com fator de interpolação igual a
2, conforme destacado na Figura 23. Nessa figura desconsiderou-se a latência do circuito
interpolador para facilitar a visualização da correspondência entre o fluxo de pixels da entrada
e o fluxo de pixels da saída.
A partir da Figura 23 pode-se comprovar que um pixel interpolado com valor igual a
75 foi inserido entre os dois primeiros pixels adjacentes da entrada, cujos valores são 60 e 90,
respectivamente. O pixel com valor igual a 75 é exatamente igual à média aritmética simples
Figura 23 – Sequência dos pixels na entrada e na saída do Bloco de Processamento da
Interpolação utilizando interpolação linear com fator de interpolação igual a dois.
Fonte: Elaborado pelo autor
Seqüência de pixels na entrada d_in
Seqüência de dados na saída d_out
62
dos pixels com valores iguais a 60 e 90. Analisando-se a seqüência de pixels na entrada e na
saída, vê-se que o processo se repete, e o fluxo de pixels na saída do Bloco de Processamento
da Interpolação corresponde ao fluxo de pixels na entrada do bloco com a inserção de um
pixel interpolado entre cada dois pixels de entrada consecutivos. Observa-se ainda que a taxa
de pixels na saída (um pixel a cada período de clock), é o dobro da taxa de pixels na entrada.
Outra análise importante é o comportamento do circuito interpolador de imagem ao final de
uma linha. Deve-se observar com cuidado esse ponto, uma vez que os pixels da imagem de
entrada são armazenados na memória de forma seqüencial, ou seja, o primeiro pixel de cada
linha é consecutivo ao último pixel da linha anterior. Dessa forma, o controle de início de
cada linha é feito externamente à memória, através do sinal first_pix. Como o fator de
interpolação é igual a dois, deve ser inserido um pixel interpolado após o último pixel da
linha. No caso do interpolador linear, isso é realizado com a repetição do valor do último
pixel da linha. Contudo, o valor do(s) pixel(s) interpolado(s) após o último pixel original da
linha pode(m) variar de acordo com o tipo de interpolador e com o fator de interpolação
utilizados.
Um novo teste para verificar o funcionamento do Bloco de Processamento da
Interpolação foi utilizando interpolação linear, sobre a mesma seqüência de pixels de entrada,
mas agora com fator de interpolação igual a três, cujo diagrama de simulação temporal está
mostrado na Figura 24. Nessa situação deveriam ser inseridos dois pixels interpolados (pi)
1 i 2, entre os pixels originais (p), localizados nas posições (N), e (N+1), para
1 N tamanho da linha. Os valores dos pixels interpolados (p(i1) e p(i2)) são mostrados nas
Equações 3 e 4.
Observa-se que os pesos dos pixels p(N) e p(N+1) são iguais a 2/3 e 1/3, respectivamente,
para a determinação do pixel interpolado p(i1), mas são iguais a 1/3 e 2/3, respectivamente,
para o cálculo do pixel interpolado p(i2). Uma vez que uma das características da arquitetura é
trabalhar com ponto fixo, esses pesos na prática são informados através da utilização de
coeficientes inteiros (c_1 e c_2) inseridos na codificação VHDL do Bloco de Gerenciamento
)1()()1(3
1
3
2 NNi ppp
)1()()2(3
2
3
1 NNi ppp
(3)
(4)
63
dos Coeficientes. Esses coeficientes correspondem ao produto dos respectivos pesos por 256,
que então são arredondados para o inteiro mais próximo. O Bloco de Processamento da
Interpolação recebe como sinal de entrada esses coeficientes e executa a divisão por 256, a
fim de calcular o peso dos pixels nas posições (N+1) e (N), respectivamente. Sendo assim,
inicialmente faz-se c_1=0 e c_2=256, o que levará à cópia do pixel localizado na posição (N).
A seguir faz-se c_1=85 e c_2=171 e finalmente, c_1=171 e c_2=85, o que levará à inserção
do primeiro e do segundo pixels interpolados, respectivamente, conforme Equações 3 e 4. O
duty cycle do sinal d_ena foi 33% para temporizar corretamente a inserção dos pixels na
geração do fluxo serial de pixels na saída (d_out).
A partir da Figura 24, observa-se que os pixels na saída d_out começam a aparecer
após oito ciclos de clock. A latência maior do circuito interpolador de imagem com fator de
interpolação igual a três, se comparada ao caso em que o fator de interpolação é igual a dois,
deve-se ao maior número de operações realizadas no primeiro caso. Como pode ser visto na
Figura 4.3 o pixel inicial do sinal de entrada d_in, tem valor igual a 60, e está sincronizado
com a ocorrência do sinal first_pix que indica o início de uma linha. Nesse teste foram
utilizadas linhas compostas por apenas seis pixels e, portanto o último pixel da linha tem valor
igual a 120.
Observa-se no fluxo de dados de saída (d_out) que entre o primeiro pixel da linha e o
seu consecutivo foram inseridos dois pixels interpolados com valores iguais a 69 e 80, em
concordância com o fator de interpolação igual a três e com os coeficientes introduzidos. Um
erro pode ser verificado no valor do primeiro pixel interpolado que deveria ser 70 e foi
calculado como 69. Esse erro representa um percentual de apenas 0,4% do valor de pico do
valor real. A explicação para esse erro vem do fato de que o peso de cada pixel de entrada
para a formação do valor do pixel interpolado corresponde ao resultado da divisão entre os
respectivos coeficientes do interpolador (c_1 e c_2) e 256. Essa operação utiliza ponto fixo e
Figura 24 – Diagrama temporal do Bloco de Processamento da Interpolação
utilizando interpolação linear com fator de interpolação igual a três
Fonte: Elaborado pelo autor
64
arredonda o resultado para o inteiro mais próximo. Como os coeficientes utilizados, 1/3 e 2/3,
multiplicados por 256 não produzem números inteiros surge o erro acima citado. Outra
observação importante é que, com o fator de interpolação igual a três, a taxa de pixels de
saída, que equivale à freqüência do sinal de clock, é três vezes a taxa de pixels na entrada.
O comportamento do Bloco de Processamento da Interpolação ao final de uma linha
da imagem de entrada também é analisado. A Figura 25 mostra a seqüência dos pixels na
entrada e ao final de uma linha, desconsiderando-se o período de latência.
A partir da Figura 25 é possível observar que após o último pixel da entrada, com
valor igual a 120, são inseridos dois pixels interpolados com esse mesmo valor, atendendo aos
requisitos do fator de interpolação igual a três. A repetição do valor do último pixel por duas
vezes é conseqüência do tipo de interpolação e do número de pixels levado em consideração
para a criação do pixel interpolado. Futuramente a forma de tratamento das bordas da imagem
poderá ser configurável.
4.2. TESTES FUNCIONAIS DO CIRCUITO INTERPOLADOR DE IMAGEM
Após os resultados corretos obtidos nos primeiros testes do Bloco de Processamento
da Interpolação, com interpolação linear, foram planejados novos testes para verificar a
arquitetura completa do circuito interpolador de imagem apresentada na Figura 10 para
realizar a interpolação de pixels em uma linha de imagem, com fator de interpolação igual a
dois, utilizando-se três tipos de interpoladores: Interpolador de ordem zero (vizinho mais
próximo), interpolador de primeira ordem (linear) e interpolador de terceira ordem (Lanczos).
A imagem a ser interpolada foi inserida no Bloco de Memória de Entrada. Os coeficientes,
Seqüência de pixels na entrada d_in
Seqüência de pixels na saída
Figura 25 – Sequência de pixels ao final de uma linha na entrada e na saída do Bloco de
Processamento da Interpolação utilizando interpolação linear com fator de interpolação igual a três.
Fonte: Elaborado pelo autor
65
correspondendo aos respectivos pesos multiplicados por 256 e arredondados para o inteiro
mais próximo, foram inseridos no Bloco de Gerenciamento de Coeficientes. Todos os sinais
de controle foram gerados automaticamente pelo Bloco de Controle, de acordo com o fator de
interpolação e o tamanho da linha a ser interpolada, que também corresponde, nesse caso, ao
tamanho total da memória.
Não foram realizados testes com polinômios interpoladores de segunda ordem porque
o objetivo aqui era verificar o funcionamento do circuito interpolador de imagem,
reconfigurando-se estaticamente o tipo de interpolador a ser utilizado, bem como o fator de
interpolação. Não é objetivo principal dessa dissertação a comparação visual ou quantitativa
entre diferentes tipos de interpoladores.
A verificação dos resultados da interpolação foi feita de três maneiras diferentes:
a) Análise subjetiva através da inspeção visual, comparando-se a imagem original à imagem
interpolada (KHIEOVONGPHACHANH, 2008,);
b) Análise objetiva, utilizando-se como indicadores o MSE, dado pela Equação 5, e a
correspondente PSNR, dada pela Equação 6, entre a imagem original e a imagem
interpolada (KHIEOVONGPHACHANH, 2008, WEI-YU HAN, 1997);
em que: M é o número de linhas; N é o número de colunas; i, j são as coordenadas da
posição (linha, coluna), x é o pixel na imagem original e é o pixel na imagem
interpolada.
c) Comparação entre os resultados da interpolação realizada no Matlab, utilizando
algoritmos desenvolvidos durante este trabalho, e a interpolação realizada pelo circuito
interpolador de imagem. Para essa comparação foram utilizadas análises subjetivas através
da inspeção visual e quantitativa através da comparação das medições do MSE e da PSNR
das duas imagens interpoladas.
x̂
N
j
M
i
jixjixNM
MSE1
2
1
)),(ˆ),((1
(5)
MSEdBPSNR
2255log10)(
(6)
66
Para a realização dos testes, foram geradas no Matlab duas linhas de imagem com 128
amostras igualmente espaçadas variando segundo uma função cossenoidal com picos nos
valores 0 (preto) e 255(branco), mas com freqüências distintas. Os resultados obtidos nos
cálculos dos valores das amostras foram arredondados para o inteiro mais próximo.
A primeira linha de pixels correspondeu a aproximadamente 1,25 período da função
cossenoidal e nos testes apresentados, será denominada “Linha 1”. A segunda linha de pixels
correspondeu a aproximadamente 12,5 períodos, e nos testes apresentados será denominada
“Linha 2”. Ressalta-se que nesta fase dos testes, os sinais “Linha 1” e “Linha 2” serão
interpolados um de cada vez, utilizando-se separadamente o Circuito Interpolador de Imagens.
A distribuição dessas 128 amostras de cada linha de pixels está mostrada na Figura 26.
A seguir essas duas linhas de imagem foram subamostradas à razão 2:1, ou seja,
tomando-se uma amostra e descartando-se a amostra seguinte. Dessa forma, ao interpolar as
linhas da imagem subamostrada com o uso de interpoladores usando fator de interpolação
igual a dois, a quantidade de amostras pôde ser recuperada. As linhas sub-amostradas são
mostradas na Figura 27.
Deve-se ressaltar que no procedimento de subamostrar esses sinais foi obedecido o
Teorema da Amostragem de Nyquist (PRATT, W. 2001), uma vez que a freqüência de
amostragem foi superior à freqüência do sinal. Nesse sentido, um interpolador ideal deve ser
0 32 64 96 1280
64
128
192
256Linha 1
0 32 64 96 1280
64
128
192
256Linha 2
Figura 26 – Sinais “Linha 1” e “Linha 2” com 128 amostras
Fonte: Elaborado pelo autor
67
capaz de reconstruir o sinal original com 128 amostras sem nenhuma distorção. Observa-se no
sinal “Linha 2” que os pontos de mínimo do sinal original não fazem parte do sinal
subamostrado, o que causa uma aparente distorção no sinal. Utilizando o circuito interpolador
de imagens, será possível verificar a eficiência de alguns interpoladores usuais para a
interpolação desses sinais.
4.2.1. Interpolador de ordem zero: vizinho mais próximo
Para a utilização da interpolação de ordem zero é necessário inicialmente carregar no
Bloco de Gerenciamento dos Coeficientes os valores que serão utilizados pelo circuito
interpolador de imagem no cálculo dos pesos para esse tipo de interpolação. Como a
interpolação é realizada sobre o sinal unidimensional, subamostrado, o tamanho da linha de
pixels de entrada é igual a 64. Portanto definiu-se no Bloco de Memória de entrada o tamanho
de 64 bytes para o armazenamento dos pixels de entrada do Bloco de Processamento da
Interpolação. A Figura 28 mostra o resultado da simulação temporal da interpolação do sinal
“Linha 1”.
Figura 27 – Sinais “Linha 1” e “Linha 2” subamostrados com 64 amostras
Fonte: Elaborado pelo autor
68
Nesse diagrama o sinal rd_mem_size é enviado pelo Bloco de Controle ao contador
que endereça a memória de entrada informando o tamanho do Bloco de Memória de Entrada.
O sinal lin_mem_size é enviado ao Bloco de Processamento da Interpolação, para permitir a
correta operação na interpolação do último pixel da linha, impedindo que ele seja interpolado
com o pixel da linha seguinte.
O sinal interp_r (Fator de interpolação) é enviado pelo Bloco de Controle para o Bloco de
Gerenciamento dos Coeficientes a fim de selecionar corretamente os valores a serem
utilizados no cálculo dos pesos. Os pixels de entrada aparecem no sinal d_mem e os pixels de
saída no sinal d_out, que representam, respectivamente, a entrada de dados e a saída do Bloco
de Processamento da Interpolação. Na entrada, o valor do primeiro pixel (255) é repetido até
que o Bloco de Processamento da Interpolação receba a informação de que ele está estável na
entrada do Bloco de Processamento da Interpolação, através do sinal first_pix. Inicialmente
deve-se observar a latência de seis ciclos de clock entre a liberação do primeiro pixel para
processamento, representada pela passagem de nível lógico alto para nível lógico baixo do
sinal first_pix, e o primeiro pixel válido na saída d_out. Esse primeiro pixel corresponde à
cópia do primeiro pixel do sinal de entrada. A partir desse instante observa-se na Figura 28
que os pixels na saída correspondem à interpolação dos pixels da entrada utilizando fator de
interpolação dois e o método do vizinho mais próximo. Um detalhe importante a ser
observado é que a taxa de pixels na saída d_out é dobro da taxa de pixels na entrada d_mem
apesar de visualmente parecer na Figura 28 que elas são iguais. Isto é, a cada pulso de clock,
um pixel é inserido no fluxo de pixels da saída (seja ele um pixel pertencente à imagem
original ou a um pixel interpolado), mas a leitura de um pixel da imagem original no Bloco de
Figura 28 –Diagrama temporal da interpolação do sinal “Linha 1” utilizando interpolador
de ordem zero e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
69
Memória de Entrada ocorre somente a cada dois ciclos de clock do circuito. Deve-se lembrar
que o duty cycle do sinal d_ena está diretamente relacionado ao fator de interpolação e, no
teste em questão, ele é igual a 50%, o que representa fator de interpolação igual a 2.
Para verificar o funcionamento do circuito interpolador de imagem, o sinal à saída do
Bloco de Processamento da Interpolação, já com 128 amostras, foi comparado ao sinal
“Linha 1” original (com 128 amostras gerado no Matlab). A Figura 29 mostra o sinal
“Linha 1” original e sobreposto ao sinal “Linha 1” interpolado.
As amostras originais são representadas por um pequeno círculo e as amostras do sinal
interpolado são representadas com um x. Observa-se que o sinal interpolado corresponde à
repetição de cada amostra do sinal original subamostrado, acompanhado do pixel interpolado
que, nesse caso, é a repetição do vizinho mais próximo (pixel à esquerda da posição onde é
inserido o pixel interpolado).
Após a finalização dos testes de interpolação do sinal “Linha 1”, procederam-se os
testes de interpolação do sinal “Linha 2”. Para isso, foram carregadas no Bloco de Memória
de Entrada as amostras do sinal “Linha 2”, também subamostrado, correspondendo a 64
pontos. O resultado da simulação temporal da interpolação do sinal “Linha 2” é mostrado na
Figura 30.
Figura 29 – Sinal “Linha 1” original (o) e sinal “Linha 1” interpolado (x) correspondente
utilizando interpolador de ordem zero e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
70
Verifica-se aqui, mais uma vez, que os resultados à saída do circuito interpolador
apresentam-se conforme o esperado, uma vez que o fluxo de pixels na saída sempre apresenta
o pixel original seguido do pixel interpolado (repetição do valor adjacente à esquerda).
Aqui também se observa uma latência de seis ciclos de clock; idêntica à observada na
interpolação do sinal “Linha 1”. Isso ocorre porque o fator de interpolação é o mesmo e o
tempo de processamento da interpolação é o mesmo em ambos os casos.
Finalmente o sinal interpolado à saída foi comparado, utilizando o Matlab, ao sinal
original com 128 amostras. A Figura 31 mostra as amostras do sinal original sobrepostas às
amostras do sinal subamostrado interpolado.
Figura 30 – Diagrama temporal da interpolação do sinal “Linha 2” utilizando interpolador
de ordem zero e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
Figura 31 – Sinal “Linha 2” original (o) e Sinal “Linha 2” interpolado (x) correspondente
utilizando interpolador de ordem zero e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
71
Da mesma forma que na Figura 29, as amostras originais são representadas por um
pequeno círculo e as amostras do sinal interpolado por um x.
Nos resultados apresentados nas Figuras 29 e 31, relativos à utilização de um
interpolador de ordem zero, observa-se, a partir de inspeção visual, uma distorção do sinal
sub-amostrado interpolado em relação ao sinal original. Essa distorção levou a um MSE igual
a 62,86, correspondendo a uma PSNR igual a 69,42dB para o sinal “Linha 1” interpolado e a
um MSE igual a 1550,90, correspondendo a uma PSNR igual a 37,36dB para o sinal “Linha
2” interpolado.
Foram realizadas ainda as interpolações, utilizando o vizinho mais próximo e com
fator de interpolação dois, dos sinais “Linha 1” e “Linha 2”, subamostrados, utilizando
programa desenvolvido no Matlab. Os resultados de MSE e PSNR foram exatamente os
mesmos, uma vez que, nesse caso, não é realizado nenhum cálculo para determinação do pixel
interpolado.
4.2.2. Testes com um interpolador de primeira ordem: Linear
Neste teste foram utilizados como entrada os mesmos sinais “Linha 1” e “Linha 2”
subamostrados conforme mostrados na Figura 27. Para alterar o tipo de interpolação é
necessária apenas a alteração dos valores dos coeficientes no Bloco de Gerenciamento dos
Coeficientes, de forma que o interpolador realize a interpolação linear. Foi mantido neste teste
o fator de interpolação igual a 2, bem como o tamanho da linha igual e o tamanho do Bloco de
Memória de Entrada iguais a 64.
O diagrama temporal com o resultado da simulação é mostrado na Figura 32.
Pode-se ver que a latência de seis ciclos de clock permanece, pois a quantidade de
operações realizadas para calcular os pixels na saída não dependem do tipo de interpolação a
ser realizada, e sim do fator de interpolação. Verifica-se também que o sinal d_out
corresponde à repetição dos pixels de entrada intercalados pelos pixels interpolados, cujos
valores agora correspondem à média dos valores dos pixels originais adjacentes, presentes no
sinal de entrada d_mem.
Uma das verificações efetuadas foi a comparação entre o sinal interpolado gerado na saída do
interpolador e o sinal “Linha 1” original, com 128 amostras, gerado no Matlab.
72
O gráfico da Figura 33 mostra as amostras do sinal original, representadas por um
pequeno círculo, e do sinal interpolado, representadas com um “x”.
Observa-se visualmente que os pixels interpolados aproximaram-se bastante dos pixels
presentes no sinal original. Como já era esperado a interpolação linear apresentou melhores
resultados na reconstrução do sinal “Linha 1”, quando comparada à interpolação utilizando o
método do vizinho mais próximo, uma vez que o pixel interpolado é a média aritmética
simples entre os dois pixels adjacentes.
Figura 32 – Diagrama temporal da interpolação do sinal “Linha 1” utilizando interpolador
de primeira ordem e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
Figura 33 – Sinal “Linha 1” original (o) e Sinal “Linha 1” interpolado (x) correspondente,
utilizando interpolador de primeira ordem e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
73
O mesmo teste anteriormente descrito para a interpolação do sinal “Linha 1” foi feito
para o sinal “Linha 2” e o resultado da simulação temporal é mostrado na Figura 34.
Verifica-se que após a latência de seis ciclos de clock os pixels válidos surgem na
saída d_out. Vale ressaltar que o primeiro pixel na entrada d_mem não se altera, ou seja,
nenhum pixel novo é lido, até que o sinal de controle first_pix comute de nível lógico alto
para nível lógico baixo. Ressalta-se ainda que um novo pixel na saída ocorre a cada ciclo de
clock (50ns na simulação realizada), ao passo que um novo pixel de entrada é lido a cada dois
ciclos de clock (100ns na simulação realizada). Pode-se observar que na saída d_out foi
inserido um pixel interpolado entre cada dois pixels originais. O valor do pixel interpolado
corresponde à média aritmética simples dos pixels originais adjacentes truncado na parte
inteira.
O sinal interpolado gerado na saída do interpolador foi então comparado ao sinal
“Linha 2”, original com 128 amostras, gerado no Matlab. O gráfico da Figura 35 mostra as
amostras do sinal original, representadas por um pequeno círculo e do sinal interpolado,
representadas com um “x”.
É possível observar que à saída do circuito interpolador ocorreram pixels interpolados
bastante distintos dos pixels presentes no sinal original. Isso ocorreu porque o interpolador de
primeira ordem não foi capaz de reconstruir sem erros as 128 amostras do sinal original
“Linha 2” a partir do sinal subamostrado, em que não estavam presentes nenhum dos pixels
com valor nulo, conforme apresentado na Figura 31. Ressalte-se, contudo que os erros não são
unicamente devidos à implementação em hardware, mas principalmente, à natureza do
Figura 34 – Diagrama temporal da interpolação do sinal “Linha 2” utilizando interpolador
de primeira ordem e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
74
algoritmo de interpolação linear. Esse tipo de interpolação só seria capaz de calcular os
valores de amostras interpoladas sem erro caso o sinal de entrada fosse linear.
Como era esperado, nos resultados apresentados nas Figuras 33 e 35, relativos à
utilização de um interpolador de primeira ordem para gerar 128 amostras a partir de sinais
subamostrados com 64 amostras, observa-se, a partir de inspeção visual que as amostras
interpoladas à saída do circuito aproximaram-se mais das amostras do sinal original no caso
do sinal “Linha 1” (baixa freqüência), do que no caso do sinal “Linha 2” (alta freqüência).
Essa diferença na qualidade do interpolador linear pode ser quantificada através dos cálculos
do MSE e da PSNR. Para o sinal “Linha 1” obteve-se um MSE igual a 0,59, correspondendo a
uma PSNR igual a 116,17dB e para o sinal interpolado “Linha 2” obteve-se um MSE igual a
178,20, correspondendo a uma PSNR igual a 59,00dB.
O Erro Médio Quadrático, que corresponde à média dos erros existentes entre os
pixels interpolados, calculados a partir das amostras do sinal subamostrado com 64 amostras,
e os pixels do sinal original, com 128 amostras, deve-se, como já mencionado, a duas origens
Figura 35 – Sinal “Linha 2” original (o) e Sinal “Linha 2” interpolado (x) correspondente,
utilizando interpolador de primeira ordem e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
75
distintas: primeiro à própria natureza do algoritmo de interpolação e segundo, às limitações da
implementação em hardware, como por exemplo, a limitação do número de bits para a
representação das grandezas envolvidas no processo. Para a compreensão do que representam
as perdas de implementação, foram realizadas simulações no Matlab com interpoladores
lineares usando fator de interpolação igual a 2 para processar os sinais subamostrados
“Linha 1” e “Linha 2”. Como o Matlab processa em ponto flutuante, nesse caso não ocorrem
perdas de implementação, diferentemente do circuito interpolador, que processa em ponto
fixo e só trabalha, nesta implementação, com grandezas inteiras. Os resultados obtidos com a
simulação do algoritmo de interpolação linear no Matlab foram os seguintes:
MSE igual a 0,48 (correspondendo a uma PSNR igual a 118,23dB) na interpolação do
sinal “Linha 1” e um MSE igual a 179,61 (correspondendo a uma PSNR igual a 58,92dB) na
interpolação do sinal “Linha 2”.
4.2.3. Testes com um interpolador de terceira ordem: Lanczos
Como último teste para verificar o circuito interpolador de imagem carregaram-se no
Bloco de Gerenciamento dos Coeficientes as constantes que seriam utilizadas para o cálculo
dos pesos de acordo com o filtro com janela de Lanczos. Esse interpolador é de terceira
ordem, ou seja, para calcular o valor de um dado interpolado, considera o efeito de quatro
outros dados originais adjacentes. Os pixels originais considerados são: pixel(N-1); pixel(N);
pixel(N+1) e pixel(N+2), em que N é a posição do pixel corrente, sabendo-se que o(s) pixel(s)
interpolado(s) será(ão) inserido(s) entre os pixels das posições (N) e (N+1). Nos testes,
também foi utilizado um fator de interpolação igual a 2. A simulação temporal do circuito,
mostrada na Figura 36, utilizou como entrada o sinal “Linha 1” apresentado na Figura 27a.
Com o fator de interpolação igual a dois, apenas um pixel interpolado será inserido
entre cada dois pixels originais do sinal subamostrado. De acordo com os coeficientes de
Lanczos esse pixel interpolado Pi terá seu valor calculado com base na Equação 7:
)2()1()()1(
16
1
16
9
16
9
16
1ointerpoladPixel NNNN pppp (7)
76
Assim como no caso do interpolador de ordem zero e do interpolador linear, o circuito
apresentou uma latência de seis períodos de clock, contados entre o instante em que os pixels
estavam disponíveis e válidos para o processamento na entrada d_mem e o instante em que os
pixels referentes ao sinal interpolado começam a ser gerados na saída (d_out).
O sinal interpolado gerado na saída do interpolador foi então comparado ao sinal
“Linha 1”, original com 128 amostras, gerado no Matlab. O gráfico mostrando as amostras do
sinal original e do sinal interpolado é mostrado na Figura 37. As amostras originais são
representadas por um pequeno círculo e as amostras do sinal interpolado são representadas
com um x.
Figura 37 – Sinal “Linha 1” original (o) e Sinal “Linha 1” interpolado (x) correspondente,
utilizando interpolador de terceira ordem e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
Figura 36 – Diagrama temporal da interpolação do sinal “Linha 1” utilizando interpolador
de terceira ordem e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
77
Observa-se visualmente que praticamente não existe erro entre a amostra do sinal original e a
amostra do sinal interpolado.
A seguir, os mesmos testes foram realizados utilizando-se como entrada o sinal “Linha
2” subamostrado com 64 amostras, apresentado na Figura 4.6b. Nesse caso, o resultado da
simulação temporal do circuito interpolador utilizando os coeficientes de Lanczos é mostrado
na Figura 38.
O sinal interpolado gerado na saída do interpolador foi então comparado ao sinal
Linha 2, original com 128 amostras, gerado no Matlab. O gráfico da Figura 39 apresenta as
amostras do sinal original, representadas por um pequeno círculo, e do sinal interpolado
representadas com um “x”. Nos resultados apresentados nas Figuras 37 e 39, relativos à
utilização de um interpolador de terceira ordem, observa-se a partir de inspeção visual que
ambos os sinais, “Linha 1” e “Linha 2”, foram reconstruídos aproximando-se dos sinais
originais. Essa observação pode ser quantificada através dos cálculos do MSE e da PSNR.
Para o sinal Linha 1 obteve-se um MSE igual a 0,45, correspondendo a uma PSNR igual a
118,74dB e para o sinal interpolado Linha 2 obteve-se um MSE igual a 45,79,
correspondendo a uma PSNR igual a 72,58dB. Pela análise destes resultados constata-se que
para o sinal Linha 1 os resultados do interpolador linear e de Lanczos aproximam-se bastante
(o segundo apresentou um ganho de cerca de 2,6dB). Já para o sinal Linha 2 o interpolador de
terceira ordem Lanczos apresenta muito melhores resultados (ganho em torno de 19,6dB)
como pode ser constatado pela análise subjetiva dos sinais.
Figura 38 – Diagrama temporal da interpolação do sinal “Linha 1” utilizando interpolador
de terceira ordem e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
78
A seguir foram realizadas as interpolações utilizando o interpolador de terceira ordem
segundo o filtro de janelamento de Lanczos com fator de interpolação dois para
processamento dos sinais “Linha 1” e “Linha 2” subamostrados apresentados na Figura 67,
utilizando um algoritmo desenvolvido no Matlab. Obviamente, foram encontradas diferenças
entre os pixels interpolados determinados pelo circuito interpolador e os pixels interpolados
calculados pelo Matlab, uma vez que o circuito processa apenas inteiros e não utiliza ponto
flutuante, ao contrário do Matalab. Os resultados de MSE e PSNR foram então calculados
obtendo-se um MSE igual a 0,37 correspondendo a uma PSNR igual a 120,89dB para a
interpolação do sinal “Linha 1”, e um MSE igual a 44,83 correspondendo a uma PSNR igual a
72,80dB para a interpolação do sinal “Linha 2”. Verifica-se que o erro introduzido pela
utilização de ponto fixo é bastante pequeno face à simplificação introduzida nos cálculos e,
por conseqüência, à otimização de tempo e recursos no processamento.
Observa-se visualmente que, comparando-se o interpolador de terceira ordem às duas
técnicas de interpolação anteriormente testadas, que são o interpolador de ordem zero e o
interpolador linear, o interpolador de terceira ordem, que utiliza os coeficientes de Lanczos,
apresenta melhores resultados, gerando pixels interpolados com valores mais próximos dos
Figura 39 -Sinal “Linha 2” original (o) e Sinal “Linha 2” interpolado (x) correspondente,
utilizando interpolador de terceira ordem e fator de interpolação igual a 2.
Fonte: Elaborado pelo autor
79
valores do sinal original, com 128 amostras. A razão para isso é que esse interpolador é o que
mais se aproxima, dentre os implementados, da função de interpolação ideal, que é a função
sinc.
Deve-se salientar, mais uma vez, que não é objetivo deste trabalho comparar diversos
métodos e/ou polinômios de interpolação, mas os dados obtidos além de comprovarem o
funcionamento do circuito interpolador de imagem proposto, ainda permitem realizar essa
análise comparativa como pode ser visto na Tabela 3.
Sinal Linha 1 Linha 2
Interpolador FPGA MATLAB FPGA MATLAB
Ordem zero (vizinho
mais próximo)
MSE 62,86 62,86 1550,90 1550,90
PSNR (dB) 69,42 69,42 37,36 37,36
Primeira ordem
(linear)
MSE 0,59 0,48 178,20 179,61
PSNR (dB) 116,17 118,23 59,00 58,92
Terceira ordem
(Lanczos)
MSE 0,45 0,37 45,79 44,83
PSNR (dB) 118,74 120,89 72,58 72,80
4.3. TESTES COM UMA IMAGEM REAL
Após os bons resultados dos testes da primeira fase, com o Bloco de Processamento da
Interpolação, e posteriormente, com os testes do circuito interpolador de imagem trabalhando
com sinais unidimensionais, realizaram-se novos testes utilizando-se uma imagem real. A
imagem escolhida foi a imagem acromática “Fishing boat”, mostrada na Figura 40, imagem
clássica e bastante conhecida por quem trabalha no processamento digital de imagens.
Tabela 3 – Tabela comparativa dos resultados quantitativos obtidos
Fonte: Elaborada pelo autor
80
É importante ressaltar, contudo, que será usado o circuito interpolador para sinais
unidimensionais, cuja arquitetura de hardware reconfigurável foi apresentada na Figura 10.
Valendo-se do Princípio da Separabilidade, serão processadas primeiro as colunas da imagem
“Fishing boat” e posteriormente, serão processadas as linhas resultantes do processamento no
sentido vertical.
4.3.1. Teste com interpolação em duas dimensões sobre bloco da imagem
Na imagem “Fishing boat”, inicialmente foi escolhido um pequeno bloco composto
por 32 linhas e 16 colunas, totalizando 512 pixels ou 512 bytes, uma vez que cada pixel da
imagem é codificado utilizando 8 bits. Esse bloco, a partir de agora denominado “bloco
original”, foi então subamostrado tanto verticalmente quanto horizontalmente à razão 2:1, ou
seja, tomando-se uma amostra e descartando-se a amostra seguinte. Dessa forma, passou a ter
apenas 16 linhas e 8 colunas.
Inicialmente realizou-se a interpolação sobre as colunas da imagem e depois, sobre as
linhas da imagem já interpolada no sentido vertical. A interpolação utilizou os coeficientes de
Lanczos com fator de interpolação igual a dois. Isso produziu um bloco interpolado com
dimensões iguais às do bloco original.
Figura 40 – Imagem Fishing boat utilizada nos testes com imagens reais.
(Fonte: Signal and Image Processing Institute at the University of Southern California).
81
Os pixels da saída do circuito interpolador de imagens foram comparados com os
pixels do bloco original para o cálculo do valor de MSE=159,01. Esse erro corresponde a uma
PSNR de 60,14dB.
Um trecho da memória contendo parte do bloco de imagem com os pixels originais é
mostrado na Tabela 4 e, com os pixels interpolados, na Tabela 5.
162 163 163 161 157 167 159 166 166 169 150 103 88 139 169 163
167 156 167 162 158 158 168 159 161 172 154 111 76 172 161 170
164 158 158 168 157 156 161 171 152 174 176 123 100 170 166 169
163 156 159 163 157 157 163 163 162 184 165 138 111 165 167 169
157 168 159 160 159 163 164 163 170 181 168 152 142 149 158 159
160 163 159 161 163 167 165 172 171 173 161 171 158 147 147 145
163 159 158 161 166 160 172 171 176 180 173 170 155 158 138 134
163 164 161 156 171 168 175 170 176 190 176 162 158 147 137 127
161 167 158 164 166 173 175 167 180 193 159 164 151 146 133 129
160 167 158 169 159 183 163 180 170 177 157 152 151 142 143 127
Os valores marcados em cinza representam os pixels originais que foram mantidos após a
realização da subamostragem do bloco de imagem original.
162 162 163 159 157 157 159 163 166 162 150 112 88 124 169 174
163 161 160 157 156 157 159 158 157 164 163 122 91 124 168 172
164 161 158 156 157 159 161 155 152 168 176 135 100 128 166 170
160 159 158 156 157 159 162 160 159 169 173 144 120 138 163 165
157 158 159 158 159 161 164 167 170 171 168 153 142 148 158 159
159 158 158 159 162 165 168 170 173 173 170 160 151 148 147 147
163 160 158 161 166 169 172 174 176 175 173 164 155 145 138 136
162 159 157 161 167 171 175 179 180 174 167 161 155 144 135 133
161 159 158 161 166 170 175 179 180 170 159 154 151 141 133 131
161 158 157 158 161 162 163 164 164 155 147 142 138 131 126 124
Nesse teste não foi realizada uma comparação com os resultados obtidos no Matlab uma vez
que, devido ao curto tempo disponível, não foi desenvolvido um algoritmo para realizar a
interpolação utilizando os coeficientes de Lanczos. Além disso, mais uma vez ressaltamos
que, o objetivo dos testes é verificar o funcionamento do circuito interpolador de imagens e a
comparação com os resultados obtidos no Matlab não é necessária em todas as situações
testadas.
Tabela 4 – Valores dos pixels no bloco original
Tabela 5 – Valores dos pixels no bloco de imagem após aplicar a interpolação
Fonte: Elaborada pelo autor
Fonte: Elaborada pelo autor
82
4.3.2. Teste com interpolação linear unidimensional sobre uma imagem
Como último teste para verificar o circuito interpolador de imagem foi utilizada a
imagem “Fishing boat” completa, ou seja, com 256 linhas por 256 colunas. Essa imagem foi
sub-amostrada em suas colunas à razão de 2:1, transformando-se em uma imagem com 256
linhas e 128 colunas. Os valores dos níveis de cinza dos pixels que compõem essa imagem
foram inseridos no Bloco de Memória de Entrada do circuito interpolador de imagem, a fim
de que fosse realizada uma interpolação linear sobre as colunas da imagem subamostrada,
com fator de interpolação igual a dois. Nesse teste utilizou-se a interpolação linear porque os
resultados do circuito interpolador de imagens serão comparados com os resultados obtidos
através da aplicação do algoritmo desenvolvido no Matlab para realização da interpolação
linear. A mesma imagem subamostrada foi carregada no Matlab a fim de que tivesse suas
colunas interpoladas com fator de interpolação igual a dois, utilizando-se o algoritmo do
interpolador linear desenvolvido no próprio ambiente Matlab.
Após realizadas as interpolações, ambas as imagens, a primeira gerada pelo circuito
interpolador e a segunda gerada pelo Matlab, voltaram a ter 256 linhas e 256 colunas. Os
valores dos níveis de cinza de cada pixel das imagens interpoladas pelo Matlab e pelo circuito
interpolador de imagem simulado no FPGA foram comparados através do cálculo do valor do
MSE e da PSNR, conforme apresenta a Tabela 6.
Comparando-se os resultados obtidos através do Matlab com os resultados obtidos
através da simulação do circuito interpolador de imagens com hardware reconfigurável
verificam-se valores de MSE e PSNR praticamente iguais.
Interpolação Matlab Circuito
interpolador
MSE 160,60 160,55
PSNR (dB) 60,04 60,04
Tabela 6 – Comparação do MSE e da PSNR das imagens com as colunas interpoladas
Fonte: Elaborada pelo autor
83
As imagens obtidas através da interpolação do Matlab e utilizando o circuito
interpolador de imagem são mostradas na Figura 41 apenas para permitir uma análise visual
subjetiva.
O histograma das duas imagens é mostrado na Figura 42 onde se confirma a
similaridade entre as imagens interpoladas.
Figura 42 – Histograma das imagens boat interpoladas no circuito interpolador de
imagens com hardware reconfigurável e o Matlab.
Fonte: Elaborado pelo autor
Figura 41 – Imagens com as colunas interpoladas utilizando o circuito interpolador de imagem com
hardware reconfigurável (a) e o Matlab (b),com fator de interpolação dois e interpolador linear
Fonte: Elaborado pelo autor
84
4.4. CONSIDERAÇÕES FINAIS
Todos os testes realizados, desde o teste inicial do Bloco de Processamento da
Interpolação operando dissociado dos demais blocos da arquitetura, até o teste final com uma
imagem real, permitem afirmar que o circuito interpolador de imagem com arquitetura de
hardware reconfigurável atende aos requisitos de reconfigurabilidade e flexibilidade,
funcionando de acordo com o planejado. Foi introduzida na solução final a parametrização do
tamanho do Bloco de Memória de Entrada e do tamanho da linha da imagem, o que permite
configurar diferentes formatos de imagem na entrada do circuito.
A arquitetura reconfigurável através da alteração dos coeficientes a serem utilizados na
interpolação torna o hardware bastante flexível e ágil para realizar interpolações utilizando
coeficientes de diferentes polinômios ou filtros que criam uma janela na função sinc. Uma das
qualidades do circuito é que um mesmo hardware é utilizado para realizar diferentes tipos de
interpolação independentemente da ordem do polinômio ou filtro do qual são extraídos os
coeficientes. Além disso, o tempo de processamento varia unicamente com o fator de
interpolação escolhido e, uma vez que esse parâmetro mantém-se inalterado, a latência para o
início do fluxo com os pixels interpolados inseridos entre os pixels do sinal de entrada, à saída
do circuito, permanece inalterada para diferentes polinômios ou filtros que criam uma janela
na função sinc.
A solução adotada neste projeto utiliza 177 elementos lógicos, 77 registradores e 4
multiplicadores do FPGA escolhido. Também possibilita sua implementação em um circuito
onde duas ou mais linhas da imagem a ser interpolada poderiam ser processadas
simultaneamente utilizando processamento paralelo e reduzindo o tempo necessário para se
obter a imagem interpolada na saída. Deve-se aqui salientar que qualquer interpolador de até
terceira ordem pode ser implementado na arquitetura de hardware reconfigurável
desenvolvida. A limitação imposta pelas características do projeto refere-se a utilização de
operações com números inteiros e ponto fixo.
85
5. CONCLUSÕES
Este capítulo inicialmente apresenta uma discussão dos resultados obtidos neste
trabalho, comentando-se o alcance dos objetivos e metas traçadas inicialmente e realizando-se
uma comparação com alguns trabalhos relacionados. Serão apresentadas também as principais
contribuições desta dissertação em relação a outros projetos de interpoladores mostrados no
Capítulo 2 e por fim, serão listados alguns possíveis trabalhos futuros.
5.1. DISCUSSÃO DOS RESULTADOS
Este trabalho teve como objetivo o desenvolvimento da arquitetura de hardware
reconfigurável de um circuito de interpolação de imagens digitais utilizando hardware
reconfigurável estaticamente e implementada em FPGA. Essa arquitetura foi proposta a fim
de possibilitar a realização de interpolação em uma imagem com diversos tipos de polinômios
piecewise ou filtros que criam uma janela na função sinc através de reconfiguração do
hardware. O desenvolvimento da arquitetura utilizou, para fins de simplificação e sem perda
nenhuma de qualidade, o Princípio da Separabilidade. Segundo esse princípio, dois
processamentos unidimensionais, primeiro no sentido vertical e por último no sentido
horizontal, ou vice-versa, podem ser executados consecutivamente para produzir, ao final, a
interpolação bidimensional.
Dessa forma, uma arquitetura simplificada, que realiza a interpolação unidimensional,
foi implementada em FPGA. Todos os blocos que compõem essa arquitetura foram
codificados em VHDL e apresentados, sob alguns aspectos considerados importantes, no
Capítulo 3, em que se destacou o Bloco de Processamento da Interpolação, que é aquele
responsável pelo processamento do algoritmo de interpolação propriamente dito. Nesse
capítulo foi mostrado como devem se comportar os diversos blocos que compõem a
arquitetura, apresentando também uma visão geral da solução final implementada.
A implementação de parametrização para o tamanho da memória de entrada, onde fica
armazenada a imagem a ser interpolada não estava prevista inicialmente. Contudo, o
parâmetro “Tamanho da memória” foi introduzido no Bloco de Memória de Entrada, de
forma que uma imagem de qualquer tamanho possa ser interpolada, bastando para isso utilizar
memória com capacidade adequada e alterar o valor desse parâmetro. Foi introduzido ainda o
86
parâmetro “Tamanho da linha” da imagem a ser interpolada, o que também não estava
previsto, dando maior flexibilidade ao circuito.
O principal bloco da arquitetura é o Bloco de Processamento da Interpolação,
responsável pelo processamento do algoritmo de interpolação propriamente dito. No
Capítulo 4, foram apresentados testes para verificar o funcionamento desse bloco
isoladamente, bem como em associação aos demais blocos que compõem a arquitetura do
Circuito Interpolador.
O requisito principal da arquitetura proposta, que é a possibilidade de reconfiguração
estática, também foi alcançado e pode ser realizada simplesmente alterando-se os coeficientes
que serão utilizados nos cálculos dos valores dos pixels interpolados, diretamente no Bloco de
Gerenciamento dos Coeficientes e realizando-se a geração de um novo bitstream.
Portanto, com a arquitetura proposta, é possível realizar a interpolação de sinais
unidimensionais (ou de imagens que possuem apenas uma única linha), bem como de sinais
bidimensionais, utilizando-se o circuito inicialmente para interpolar colunas (ou linhas) e por
último, interpolar linhas (ou colunas) resultantes da interpolação anterior. O grau máximo do
interpolador foi definido em três para que fosse possível limitar os recursos lógicos
necessários e tornar factível a implementação em FPGA.
Assim, considerando-se a arquitetura do circuito interpolador reconfigurável proposta
e projetada neste trabalho, apresentada em detalhes no Capítulo 3 e ainda, os resultados
obtidos através da simulação temporal do circuito apresentados no Capítulo 4, pode-se afirmar
que os objetivos e metas propostas foram alcançados e até superados em alguns momentos.
O trabalho que mais se aproximou da arquitetura proposta nesta dissertação foi a
arquitetura desenvolvida em (MARTINS, 1998) que apresentou um circuito reconstrutor de
imagens utilizando uma nova técnica chamada RSFAN-2D. Nesse trabalho a imagem
interpolada também é composta por pixels originais e interpolados e os cálculos de
multiplicação e adição são realizados separadamente. O trabalho, apesar de utilizar as técnicas
de paralelismo de operações, não desenvolveu técnicas de reconfiguração do hardware o que
o tornou específico para esta técnica de reconstrução. Na arquitetura proposta nesta
dissertação, a flexibilidade proporcionada pela reconfiguração apresenta-se como principal
diferença e vantagem.
O trabalho apresentado em (RODRIGUES, 2002), preocupa-se em tratar de forma
diferenciada as bordas da figura a fim de melhorar suas características em alta freqüência
quando a figura é interpolada. A semelhança entre esse trabalho e o aqui proposto limita-se às
87
técnicas utilizadas para verificação da qualidade das imagens interpoladas. Também foram
utilizados os métodos de inspeção visual e medição de parâmetros quantitativos.
Por último, o trabalho apresentado em (MAGANDA, 2005), assemelha-se ao dessa
dissertação por realizar a interpolação, segundo a técnica da interpolação bicúbica, de uma
imagem monocromática utilizando ponto fixo em todas as operações. Também foram
utilizados os multiplicadores disponíveis no FPGA. O trabalho foi desenvolvido utilizando a
plataforma de desenvolvimento da Xilinx e permite a reconfiguração estática do fator de
interpolação. A arquitetura aqui proposta, além de permitir a reconfiguração do fator de
interpolação, também permite a reconfiguração da técnica de interpolação a ser utilizada
proporcionando uma maior flexibilidade ao circuito.
5.2. PRINCIPAIS CONTRIBUIÇÕES
As principais contribuições desta dissertação são:
a) Proposta e desenvolvimento da arquitetura de um circuito com hardware reconfigurável
estaticamente para realizar a interpolação de imagens digitais com diferentes filtros que
criam uma janela na função sinc ou polinômios piecewise de interpolação de imagens,
possibilitando um aumento na flexibilidade do circuito digital;
b) Simulação e implementação do circuito que realiza a interpolação de imagens em FPGA
utilizando linguagem de programação VHDL, no ambiente de simulação Quartus II, da
Altera;
c) Análise dos resultados obtidos na imagem interpolada de forma subjetiva e qualitativa o
que permitiu quantificar a qualidade das imagens interpoladas pelo circuito;
d) Comparações com trabalhos correlatos mostrando vantagens e características adicionais;
e) Preparação e submissão de artigos em congressos e periódicos relacionados à área de
pesquisa.
88
5.3. TRABALHOS FUTUROS
Esta pesquisa abre a possibilidade de realização de diversos trabalhos futuros na área
de interpolação de imagens digitais. Dentre os possíveis trabalhos futuros agora vislumbrados
destacam-se:
a) Análise do impacto dos tempos de reconfiguração no desempenho computacional da
arquitetura de hardware reconfigurável do circuito interpolador de imagens digitais;
b) Aumento do grau máximo do interpolador uma vez que existem recursos disponíveis no
FPGA para isso;
c) Implementação completa do circuito interpolador bidimensional previsto no diagrama em
blocos da Figura 8;
d) Desenvolvimento de interface que permita a armazenagem da imagem interpolada em
memória externa ao FPGA;
e) Desenvolvimento de um sub-sistema que permita a leitura direta da imagem a ser
interpolada a partir de um dispositivo de armazenamento, como um disco rígido, uma
mídia óptica ou uma memória flash;
f) Desenvolvimento de um sub-sistema que permita a exibição direta da imagem interpolada
em um dispositivo de exibição de imagens como uma tela de computador.
89
REFERÊNCIAS
AMORE, Robert d’. VHDL: descrição e síntese de circuitos digitais. Rio de Janeiro: LTC,
2005.
ALTERA. Cyclone II FPGAs at Cost That Rivals ASICs.
Disponível em http://www.altera.com/devices/fpga/cyclone2/cy2-index.jsp. Acesso em: 01 de
outubro, 2008.
CHEN, J.; MOON,J.; BAZARGAN,K. A reconfigurable FPGA-based readback signal
generator for hard drive read channel simulator. Proceedings of the 39th annual Design
Automation Conference. New York, v.24, n.3, p. 349-354, june 2002.
DEHON, A.; WAWRZYNEK, J. Reconfigurable Computing: What, Why and Implications
for Design Automation. Proceedings 36th Design Automation Conference. New York,
v.35, n.1, p. 610-615, 1999.
DODGSON, N.A. Image Resampling. Technical Report. Cambridge, U.K, n.261, p. 1-76,
aug. 1992.
DODGSON, N.A. Quadratic Interpolation for Image Resampling. IEEE Transactions on
Image Processing, Cambridge, U.K , v.6, n. 9, p. 1322-1326, sept. 1997
GOKHALE, M. et al. Hardware Technologies for High-Performance Data-Intensive
Computing. Washington , v.41, n.4, p.60-68, IEEE Computer Society, 2008
GONZALEZ, R.C.;WOODS, R.E. Digital image processing. 2.ed. Pearson Education, 2002.
HAUCK, S.; DEHON, A. Reconfigurable Computing: The Theory and Practice of
FPGA-Based Computing. 1 ed. Burlington, MA, Elsevier, 2008.
HUDSON, R.D; LEHN, D.I; ATHANAS, P.M. A Run-Time Reconfigurable Engine for
Image Interpolation. IEEE Symposium on FPGAs for Custom Computing Machines.
Proceedings , Napa Valley, CA , USA, p.88-95, apr,1998.
JÄHNE, Bernd. Digital image processing. 5.ed, New York, Springer, 2002.
KHIEOVONGPHACHANH, Vimontha; HAMAMOTO, Kazuhiko Kondo Shozo. Study on
Image Quality for Medical Ultrasonic Echo Image Compression by Wavelet Transform.
International Symposium on Communications and Information Technologies, Lao,
p. 160-165, oct, 2008.
LANDIM, P. M. B. Introdução à Confecção de Mapas pelo Software Surfer. Texto didático
08. Laboratório de geomatemática, Rio Claro: UNESP, p. 22, 2002.
LEHMANN, T.M; GÖNNER, C; SPITZER, K. SURVEY: Interpolation Methods in Medical
Image Processing. IEEE Transactions on Medical imaging, Germany,v. 18, n. 11, nov.
1999.
90
MAGANDA, Marco A.N.; ESTRADA, Miguel O.A. Real-Time FPGA-based Architecture for
Bicubic Interpolation: An Application for Digital image Scaling. IEEE- Proceedings of the
2005 International Conference on Reconfigurable Computing and FPGAs, Puebla City,
p.8-15, sept. 2005.
MARSI, S; CARRATO, S; RAMPONI. G. VLSI Implementation of a non linear image
interpolation filter. IEEE Transactions on Consumer Electronics, Trieste, v. 42, n. 3, p.
721-728, aug. 1996.
MARTINS, Carlos A.P.S. Subsistema de Exibição de Imagens Digitais com
Desacoplamento de Resolução –SEID-DR. Tese de doutorado apresentada à Universidade
de São Paulo, São Paulo,1998.
MARTINS, Carlos A. P. S et al. Computação Reconfigurável: conceitos, tendências e
aplicações. XXII Jornada de Atualização em Informática (JAI). 22. ed. Campinas:
Sociedade Brasileira de Computação, 2003. v. XXII, cap. 6 p. 339-388.
MEIJERING, Erik H. W. et al. Quantitative Comparison of Sinc-Approximating Kernels for
Medical Image Interpolations. Lecture Notes in Computer Science, Berlin, v.1679, p. 210-
217, sept.1999.
MEIJERING, Erik H. W.; ZUIDERVELD, J. Karel; VIERGEVER, Max A. Image
reconstruction by Convolution with Symmmetrical Piecewise nth-Order Polinomial Kernerl.
IEEE Transactions on imaging processing, Utrecht , v. 8, n. 2, p. 192-201, feb. 1999.
MEIJERING, Erik H. Spline interpolation in mediacal imaging: Comparasion with other
convolution-based approaches. Signal Processing X: Theories and Apllications-
Proceedings of EUSIPCO, Tampere, Finland ,v. IV, p. 1089-1996, sept. 2000.
PEDRONI, Volney A. Circuit design with VHDL. USA-MA: MIT Press, 2004.
PRATT, W. Digital image processing. 3.ed. USA: John Wiley and sons inc, 2001.
RODRIGUES, Leízza; BORGES, Díbio L.; GONÇALVES, Luiz M. A Locally Adaptive
Edge-preserving Algorithm for Image Interpolation. Proceedings of the XV Brazilian
Symposium on Computer Graphics and Image Processing (SIBGRAPI’02), Fortaleza,
Brasil, p.300-305, oct. 2002.
SEDRA, Adel S. SMITH, Kenneth C. Microeletrônica. 5. ed. Brasil: Pearson Education,
p. 752-753, 2007.
SHAN, Chai et al. Robustness of a Perceptually Lossless Medical Image Coder: Interpolation.
International Symposium on Intelligent Signal Processing and Communication Systems
(ISPACS), Yonago, Japan, p.931-934, dec.2006.
HAN, Wei-Yu; LIN, JA-Chen. Minimum-maximum exclusive mean filter to remove impulse
noise from highly corrupted images. Electronics letters, v. 33, n. 2. p.124-125, jan. 1997.
XILINX. Product Support & Documentation.
Disponível em http://www.xilinx.com/support/index.htm#nav=sd-nav-link-156334&tab=tab-
sd. Acesso em: 10 de março, 2008.