ESS | FPGA for Dummies | 2015-12-08 | Maurizio Donna FPGA for Dummies Basic FPGA architecture.
SEC Relatorio FPGA
description
Transcript of SEC Relatorio FPGA
Sistemas Electrónicos de Computadores
(2011-‐2012 1º Semestre)
Instituto Superior Técnico -‐ Taguspark
Docente: Prof. Francisco Alegria
Aceleração de Algoritmos de Processamento de Imagem com FPGA Digilent S3 com Microblaze
Softcore 23 de Dezembro de 2011
Diogo Aguiam – 66010 Henrique Carvalho – 66013
Tiago Furtado – 74087
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
2
Índice
1. Introdução ........................................................................................................................................................ 3 2. Descrição do Sistema ................................................................................................................................... 4 3. Algoritmo do Histograma .......................................................................................................................... 5 4. Algoritmo de Emboss .................................................................................................................................. 8 5. Algoritmo de Equalização ........................................................................................................................ 11 6. Visualização de números ......................................................................................................................... 13 7. Explicação do EDK ...................................................................................................................................... 14 8. Medidas para a análise do desempenho do sistema .................................................................... 15 9. Análise Resultados? .................................................................................................................................... 16 10. Conclusão do Projecto ............................................................................................................................ 17 7. Bibliografia ..................................................................................................................................................... 18 8. Anexos .............................................................................................................................................................. 18
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
3
1. Introdução O segundo projecto da cadeira de Sistemas Electrónicos de Computadores consiste na
implementação de algoritmos de processamento de imagem numa placa de demonstração FPGA Digilent S3. O sistema utiliza o módulo de uma câmara de telemóvel para adquirir imagens e um monitor com entrada VGA que representa essas imagens e a imagem resultante do processamento. O objectivo do projecto é verificar as vantagens e as diferenças entre desenvolver
estes algoritmos de processamento de imagem em software e em hardware. Por cima da estrutura da FPGA implementou-‐se o softcore da Microblaze e é por cima deste que se desenvolvem os algoritmos em software. Também é recomendada a implementação de periféricos hardware para melhorar a performance do sistema e verificam-‐se esses processos. Os algoritmos a implementar são o negativo, que já é fornecido, um histograma e um
emboss da imagem captada. Estes algoritmos devem ser optimizados pois o sistema deve captar e apresentar a imagem captada e alterada em tempo real. Para além destes algoritmos, implementou-‐se também um algoritmo de equalização que permite obter um melhor contraste da imagem e um correspondente emboss mais destacado. No relatório explicam-‐se as opções tomadas, as alterações e as novas implementações
extra que não estão explícitas no enunciado.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
4
2. Descrição do Sistema Neste sistema pretende-‐se captar imagens com a câmara de vídeo e processa-‐las em
tempo real. Utiliza-‐se uma placa de demonstração FPGA cujos periféricos são a câmara e o monitor. A interface entre a FPGA e o monitor é VGA e tanto o periférico de captura de imagens da câmara de vídeo como o da comunicação com o monitor através da interface VGA já são disponibilizados juntamente com o enunciado. O foco do projecto é, portanto, desenvolver os algoritmos, em software e hardware, de processamento da imagem captada. A imagem captada pela câmara é sempre visualizada no monitor sem que o softcore
da FPGA intervenha. Paralelamente, a mesma imagem é fornecida à FPGA através da interface com a câmara, é processada, e é enviada para o periférico de interface VGA. A imagem processada aparece no monitor por baixo da imagem original. Os algoritmos a desenvolver são o histograma, o emboss e também apresentar o negativo da imagem cujo algoritmo já é fornecido. Uma das preocupações do projecto residia em conseguir representar todas os processamentos de imagem sem ter de recorrer a uma recompilação e reprogramação da FPGA. Escolheu-‐se utilizar os botões já presentes na placa de demonstração para alternar quais os processamentos de imagem activos num dado momento. Quando um dos botões está activo, o correspondente LED da placa também está ligado. Inicialmente desenvolveram-‐se os algoritmos em C num ambiente separado de modo
a se conseguir fazer o debug mais rapidamente, tal como sugerido. Utilizaram-‐se imagens arbitrárias e no final adaptou-‐se o algoritmo para a resolução da imagem captada pela câmara, que é de 128x64 pixéis de largura por altura. Para além dos três algoritmos pedidos no enunciado criou-‐se também um algoritmo de equalização. Este algoritmo foi introduzido pois verificaram-‐se valores de ruído muito acentuados na imagem capturada pela câmara e, muitas vezes, o contraste do emboss da imagem era insatisfatório. A uma pré ou pós equalização da imagem permitia aumentar grandemente o contraste, resultados que se comprovam ao ligar ou desligar este processamento através dos botões. Ter vários botões activos implica que vários processamentos são realizados em série na mesma ordem que apresentados os botões. Os botões da FPGA correspondem a passos de processamento específicos e estão
descritos na Tabela 1.
Botões 1 2 3 4 5 6
Algoritmo Negativo Pré-‐Equalização
Emboss Histograma Pós-‐equalização
Modo FPS ou ciclos
Tabela 1 -‐ Posição dos botões da FPGA e correspondente filtro de processamento de imagem activo.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
5
3. Algoritmo do Histograma Para o processamento do histograma desenvolveu-‐se o algoritmo em VHDL e em
software. Ambos são explicados.
3.1 Histograma em Software O algoritmo do histograma foi primeiramente desenvolvido em software. Um
histograma de cinzentos, que é o que se pretende neste sistema, é um gráfico cujo eixo horizontal contém os níveis de cinzentos possíveis, neste caso os 256 níveis, e o eixo vertical são o número de ocorrências. Ou seja, este algoritmo lê todos os pixéis da imagem e para cada um, verifica o seu valor e soma uma ocorrência à posição correspondente no circuito.
As considerações a ter são o tamanho da imagem representada no monitor e o objectivo de representar o histograma à escala. A imagem desejada tem um tamanho de 128 pixéis de largura e 64 pixéis de altura.
A largura é fácil de escalonar, sendo metade dos 256 níveis de cinzento disponíveis, optou-‐se por agrupar dois níveis adjacentes de cinzento somando as suas ocorrências.
Por seu lado, a altura requer considerações especiais. Pretende-‐se que o nível que contenha mais ocorrências fique no ponto máximo da imagem, ou seja, vá até ao topo da imagem. Os outros níveis e as suas ocorrências são proporcionais a este. Para criar a escala pela qual todos os valores de ocorrências são divididos assegura-‐se o valor mais alto de ocorrências e cria-‐se uma escala dividindo esse número máximo pelos 64 pixéis da altura da imagem e soma-‐se mais um para assegurar que não existem barras que saiam da imagem. Para cada valor do vector de níveis divide-‐se pela escala e obtém-‐se um valor abaixo de 64 e proporcional aos restantes.
Após se obter o vector à escala preenche-‐se a imagem a representar. Para cada pixel verifica-‐se se a sua linha está acima ou abaixo do nível correspondente na posição igual à coluna da imagem, dentro do vector. Se estiver abaixo ou igual, preenche-‐se com 0x00, preto, se for acima, preenche-‐se com branco 0xFF.
3.2 Histograma em VHDL A diferença fundamental entre o histograma escrito em C e o escrito em VHDL é que
VHDL é uma língua de descrição de hardware e C é uma linguagem de programação de software (existem variantes como System C que permitem compilar para RTL). As vantagens que isto proporciona são que VHDL cria hardware dedicado a executar a acção programada enquanto que o C que cria comandos que são interpretados por um processador.
O facto do histograma correr em hardware permite executar operações em paralelo (software executa operações sequencialmente), e o caminho físico de dados é optimizado pelo compilador enquanto que em software os comandos são optimizados para transferir os dados de forma mais eficiente em caminhos de dados fixos.
O Algoritmo para a criação do histograma é semelhante ao histograma em C:
Código 1 -‐ Algoritmo do Histograma
for(i = 0, i < number_of_pixels; i++) { histogram[pixel_value]++; }
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
6
Em software cada loop é composto por instruções executados sequencialmente. Neste caso um loop é composto pela sequência:
Considerando trivialmente que cada uma das instruções representa um ciclo do
relógio, e indicando que se tem uma imagem dada com N pixéis o histograma é demora 9N ciclos do relógio em software.
Em hardware a sequência é feita: Incrementar o valor do pixel_value anterior, ler o valor do pixel_value actual e seleccionar novo endereço na memória para o próximo flanco positivo do relógio, verificar endereço máximo do pixéis e seleccionar o próximo estado (mesmo estado).
A possibilidade de criação de múltiplos processos paralelos em hardware, o processamento de um histograma pode ser concluído em menos tempo que por software, visto que os dados são introduzidos sem atrasos significativos.
Utilizando o código já criado no ficheiro camera_interface_histogram.vhd fizeram-‐se várias modificações para garantir que o histograma fosse reduzido em tamanho para uma imagem final de 128 por 64 pixéis. Em largura é necessário reduzir os níveis de cinzentos de 256 para 128, operação realizada através duma divisão por 2, ou seja, um deslocamento do endereço de uma posição para a direita. Para reduzir o tamanho vertical do máximo da soma para 64 pixéis é criado um estado para dividir o valor num endereço de memória e o valor máximo por 2 até o valor máximo estar dentro de um limite (dado por 64 pixéis + ajuste). O valor de ajuste é necessário para garantir que valores baixos não sejam reduzidos excessivamente. A desvantagem é que permite que picos de valores muito altos passem acima dos 64 pixéis. O processo de redução é completamente combinatório implicando que a propagação do sinal deve ser inferior a 20ns (1 ciclo do relógio).
Após a divisão este resultado é passado para o FSL que envia os dados do histograma para o processador. Estes dados são depois desenhados para o ecrã em software. Não foram feitas nenhumas optimizações aos números de resultados dos valores lidos do FSL (256 valores).
Da imagem do histograma resultante é possível verificar que a câmara não captura os dois valores mais pretos nem os dois valores mais brancos, correspondentes aos inteiros 0x00, 0x01 e 0xFE, 0xFF. Com os outros grupos verificou-‐se que é um problema comum.
Figura 1 -‐ Imagem resultante do histograma de uma imagem capturada.
1. ler o valor do iterador 2. testar se iterador i é igual a number_of_pixels 3. incrementação do iterador 4. guardar o valor do iterador 5. aceder ao endereço de base mais offset por pixel_value 6. ler o valor 7. incrementar o valor 8. guardar o valor 9. saltar para o inicio do loop
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
7
Na Figura 2 tem-‐se um diagrama de estados que corresponde ao código VHDL.
Figura 2 -‐ Diagrama de estados do algoritmo do histograma em VHDL.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
8
4. Algoritmo de Emboss
4.1 Convolução da imagem O algoritmo de emboss corresponde a uma convolução de uma matriz espacial de
duas dimensões, a que corresponde a imagem capturada, com uma matriz de emboss, a que se chama Kernel ou K. No enunciado é dada uma função de convolução dada por:
!! = !.! (4.1.1)
!! = !.! (4.1.2)
! = !! − !! (4.1.3)
! é a imagem inicial, ! é a imagem final ! é a kernel de convolução, ! é a kernel inversa
!! é a convolução intermédia
Este processo pode ser simplificado juntando os dois kernels, o da convolução e o
inverso, possibilitando realizar a convolução da matriz imagem uma única vez. As matrizes finais são apresentadas.
! = !(! − !) (4.1.4)
! =−2 −2 0−2 6 00 0 0
(4.1.5)
! =0 0 00 −6 20 2 2
(4.1.6)
!!"#$% =−2 −2 0−2 12 −20 −2 −2
(4.1.7)
Na algoritmo de convolução considerou-‐se a matriz kernel 3x3 do tipo M. Assume-‐
se que a posição central tem as coordenadas (0,0), tem (-‐1,-‐1) e (1,1). Para cada pixel da matriz resultante da convolução, Y, realiza-‐se a função 4.1.9
! = ! ! !! ! !! ℎ !
(4.1.8)
!!,! = ! !!!,!!! .! !,!
!!!
!!!!
!!!
!!!!
(4.1.9)
Y é a matriz resultado da convolução I é a imagem original K é a matriz kernel final
Nos limites exteriores da imagem original, ou seja, na determinação dos pixéis
correspondentes as linhas e colunas mais exteriores da imagem pode resultar num erro
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
9
da convolução. Visto que para cada pixel é necessário saber os valores dos pixéis à sua volta, nestas posições em que o pixel a determinar não está totalmente rodeado por outros pixéis, não é possível realizar uma convolução correcta. Possíveis soluções para estas situações é realizar a convolução somente com os pixéis existentes, ou seja, nos limites da imagem ignoram-‐se os elementos da matriz kernel cuja convolução seria com pixéis fora da imagem original, ou então ignoram-‐se estes limites da imagem. A solução escolhida foi a última visto que mesmo que se realizasse a convolução com os pixéis disponíveis, resultaria num filtro de emboss errado. Optou-‐se por ignorar as linhas e colunas exteriores resultando numa imagem de 128 por 64 pixéis com uma borda de um pixel a preto a toda a volta, ou seja, 126 por 62 pixéis úteis.
Uma das sugestões é utilizar deslocamentos de bits em vez de operações de multiplicação e divisão por 2. Esta alteração do emboss não afectou melhorias significativas no desempenho do algoritmo. De modo a determinar quais e o número de deslocações a realizar implica uma lógica associada para seleccionar entre o número -‐2, 12 e 0 e o atraso resultante anula as vantagens. O MB está configurado para ter um multiplicador dedicado em hardware. Na configuração do MB utilizado neste projecto (optimizar por espaço) uma operação de multiplicação termina em 3 ciclos do relógio. No algoritmo de convolução com deslocamentos cada if representa uma instrução de branch que demora um ciclo. No caso de multiplicadores negativos, -‐2, é necessário realizar o complemento para 2. No caso da multiplicação por 12, realizou-‐se um deslocamento à esquerda de 4 posições e uma subtração de um deslocamento de duas posições: 16*A -‐4*A = 12*A.
4.2 Escalonamento da imagem O resultado da convolução é um somatório cujo resultado pode ser muito elevado,
no pior caso tem-‐se 12*255 = 3060. Para representar este valor seriam necessários 12 bits, 2^12 = 4096. No entanto a matriz imagem é uma matriz em que cada posição tem somente 8 bits, ou seja, 256 níveis de cor desde o preto ao branco. O problema põe-‐se que é preciso escalar o valor da convolução de modo a que todos os valores sejam possíveis de representar em 8 bits.
Uma solução é verificar que o maior resultado da convolução é, em módulo, 3060 e que a sua relação com 256 é de 11.953, ou seja, o inteiro de escalonamento máximo é 12. Este valor é sempre arredondado para cima de modo a evitar problemas de saturação. No entanto, na maioria das situações o resultado da convolução não alcança o seu valor máximo, ou seja, escalonar o valor obtido da convolução por 12 implica obter, na maioria dos casos, um contraste muito reduzido. É de notar que os valores obtidos da convolução têm sinal, ou seja, podem ser positivos ou negativos.
Uma das alternativas da função de emboss é fazer o cálculo da escala ideal para cada resultado da convolução e aproveitar essa escala para o frame seguinte. Esta escala é determinada actualizando, ao longo da convolução, uma variável com o valor máximo já obtido na mesma. No final da convolução realizava-‐se a função:
scale = valor_máximo / 256+1 (4.2.1)
No entanto, devido a problemas de memória, o array de memória utilizado para
guardar o resultado da convolução correspondia já à imagem final, cada elemento tinha somente 8 bits. Tentou-‐se realizar uma matriz intermédia com 32 e até de 16 bits mas o modelo do processador implementado em FPGA não disponibilizava desses recursos.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
10
Em vez de alterar o processador implementado optou-‐se por utilizar os recursos disponíveis. Esta limitação implica que o escalonamento tenha de ser realizado em simultâneo com a convolução e para cada pixel, ou seja, o valor da escala é conhecido antes da convolução.
Neste método de escalonamento, utiliza-‐se o valor de escala do frame anterior para calcular a frame corrente. O problema põe-‐se quando, dum frame para o seguinte, o valor ideal da escala se altera e resulta em pontos de saturação no novo frame. Mesmo que tal só ocorra em variações bruscas do cenário que se está a capturar, haver pixéis saturados não é desejável.
A alternativa é verificar no final do processamento de cada pixel se a escala calculada para essa imagem é diferente da utilizada. Caso haja diferença realiza-‐se o processamento de novo utilizando a nova escala. Este método evita que alguma vez haja pixéis saturados na imagem processada. Por vezes o processamento demora o dobro do número de ciclos, mas é um trade-‐off razoável.
Os valores obtidos pelo escalonamento situam-‐se entre -‐127 e +127. No entanto a matriz imagem é um vector cujos elementos têm 8 bits e são positivos. Somando +127 a esse valor obtém-‐se somente valores positivos.
Figura 3 -‐ Exemplo de um emboss comparada com a imagem original.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
11
5. Algoritmo de Equalização A equalização de uma imagem entende-‐se como a redistribuição de intensidade
(cor) de pixéis utilizando o cumulativo do histograma como função de transferência. Utilizando a curva cumulativa é possível determinar a densidade de cada intensidade pelo gradiente da curva, e é possível redistribuir a densidade de ocorrências de forma igual. Em termos visuais isto é interpretado como um aumento do contraste porque cada ocorrência presente na imagem transformada apresenta a mesma densidade.
! = ! ! = !!!"#$"%&'('$
!
!
!!!
!! é o número de pixéis a intensidade ! ! é número total de pixéis
(5.1)
Código 2 -‐ Rotina de criação do histograma de equalização e rotina de equalização.
O algoritmo utiliza uma tabela de histograma já produzida a partir de uma imagem
e acumula todos os valores. A escala é depois ajustada para que o valor se situe dentro dos limites da intensidade e número de pixéis.
A transformação da imagem inicial é aplicada utilizando o valor antigo de intensidade como índice na tabela produzindo uma imagem equalizada.
Uma comparação entre os resultados pode ser feita nas Figuras 4 a 6.
Figura 4 -‐ Imagem sem nenhum filtro activo.
for ( i=0; i < HISTOGRAM_SIZE; ++i ) {
sum += histogram[i]; cumulative_histo[i] = sum* MAX_INTENSITY / pixelCount;
} for ( i = 0; i < pixelCount; ++i ) {
outImage[i] = cumulative_histo[image[i]]; }
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
12
Figura 5 -‐ Imagem processada com filtro de equalização.
Da Figura 5 verifica-‐se um contraste ligeiramente mais acentuado, embora nesta imagem seja difícil verificar melhorias.
Figura 6 -‐ Imagem processada com filtro de pré-‐equalização e histograma activos.
Da Figura 6 é possível destacar a distorção do histograma resultante da equalização. Neste sistema optou-‐se por introduzir duas opções de equalização. Uma antes e
outra depois do filtro de emboss. Introduzir a equalização permite aumentar o contraste da imagem, pelo que a existência deste filtro antes de realizar o emboss permite obter linhas mais detalhadas. No entanto, também se optou por introduzir uma pós equalização, após o emboss, permitindo alterar a imagem que se obtinha simplesmente com o emboss. É de notar que realizar a pré e a pós equalização sem nenhum outro filtro activo é igual a realizar somente uma dessas equalizações, no entanto isso não se verifica quando se tem o emboss activo.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
13
6. Visualização de números Tanto no debugging como no final do projecto para ter mais informação visível na
imagem processada realizaram-‐se rotinas que introduzem números sobrepostos à imagem. Esta opção foi a escolhida apesar de se ter ponderado utilizar os LEDs da FPGA, ou um periférico UART que liga a FPGA ao computador. Esta última solução implicava ter duas fontes de informação, o monitor contendo a imagem e o computador para receber as mensagens de debug, e devido a existirem somente 8 LEDs, implicando valores até 256 optou-‐se por representar os valores directamente no monitor sobrepostos à imagem.
No processo de desenvolvimento foi decidido usar blocos individuais de sprites de 16*16 pixéis de forma a permitir a representação de um número 8 dígitos e facilitar a divisão de resolução horizontalmente.
Os números foram desenhados num programa gráfico e exportados sob a forma de arrays do tipo char. Cada dígito tem 256 bytes e existem dez dígitos, 0-‐9.
A rotina começa por fazer a conversão do inteiro a representar para string. Este string é então utilizado para criar um array com ponteiros a cada sprite correspondente ao digito na string. O desenho do número inteiro é feito com a deslocação absoluta de cada sprite mapeada a coordenadas absolutas da imagem base. Na iteração o valor (dado pelo valor no sprite) do pixel absoluto é escrito por cima da imagem base com Bitwise AND para permite visualização de zonas transparentes.
Figura 7 -‐ Representação do número de ciclos do filtro do negativo.
Figura 8 -‐ Representação dos FPS do filtro do negativo.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
14
7. Explicação do EDK As ferramentas do EDK permitem juntar ao processador microblaze blocos
funcionais adjuntos para serem implementados directamente em hardware. Os blocos base são as de memória local de dados (dlmb) e de de instrução (ilmb) com os associados controladores (_cntlr), a RAM (bram), o gerador de relógio (clock_generator), reset do sistema (proc_sys_reset) e o barramento local do processador (mb_plb). A interface de VGA e da camera é anexado ao projecto e comunica através dos fast simplex link (camera2mb e mb2vga).
Esta implementação adicionalmente junta mais blocos funcionais para facilitar funções adjuntas no software:
GPIO: dois blocos de GPIO foram instanciados. Um barramento de 8 bits de saida
para os 8 LEDs (leds_output_pio). O segundo bloco de GPIO é de 8 bits de entrada correspondendo aos botões dip na placa de desenvolvimento (sw_input_0). Os GPIOs estão ligados ao processador a partir do mb_plb com acessos externos adicionados ao mb.ucf . Os registos associados aos GPIOs são configurados em software a partir do API de programação do Microblaze.
Timer: O timer/counter foi instanciado para a facilitar leituras de performance dos
algoritmos sem afectar o fluxo principal de cada algoritmo. A leituras são feitas directamente ao registo do contador, permitindo ter uma contagem do número de ciclos passados entre início da contagem e leitura.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
15
8. Medidas para a análise do desempenho do sistema Uma forma de analisar o desempenho do sistema é comparar, por exemplo, os ciclos
que cada processamento de imagem demora a ser realizado. Para medir este número foi criado um timer que é iniciado a partir de 0 no loop principal. Este registo é lido no ínicio de cada processamento e mais uma vez no final, sendo a diferença entre estes valores o número de ciclos que ocorreram durante o processamento.
Código 3 -‐ Pseudo-‐código da determinação do número de ciclos
Segundo o pseudo-‐código descrito, o tempo contado não inclui o tempo de leitura e
escrita da imagem nem o tempo demorado a calcular e escrever os números. O valor de calibração serve para contabilizar o tempo demorado a fazer a leitura do registo (12 ciclos). A secção DoFilters() aplica um atraso de 15 ciclos mesmo com todas as funções desactivadas. Estes valores devem ser tidos em conta na análise do sistema.
Uma outra informação também muito importante de apresentar e que serve como
base de comparação do desempenho com os outros grupos é implementar o cálculo do framerate do processamento. Ou seja, o número de frames por segundo que se consegue obter com este processamento. Este processador apresenta uma frequência de clock de 50 MHz, implicando um período de clock de 20 ns. Multiplicando o período de ciclo pelo número de ciclos que cada processamento demora obtém-‐se essa framerate, cuja apresentação no ecrã pode ser escolhida utilizando o botão correspondente, em alternância com o número de ciclos.
while (true) {
Timer_Start(); read_image(); start_time=Timer_Get_Value(); DoFilters(); end_time = Timer_Get_Value(); time = (end_time -‐ start_time -‐ Calibration); Show_Time(time); write_image(); Timer_Stop();
}
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
16
9. Análise Resultados? É importante no projecto analisar as várias alternativas ao nosso dispor que podem
afectar a performance do nosso sistema. Um desses parâmetros é a optimização ao nível do compilador. Recorreu-‐se aos instrumentos desenvolvidos para o debugging, como é o caso do número de ciclos representados no monitor, para verificar o desempenho do sistema consoante o nível de optimização escolhido, O-‐0 a O-‐2.
Os valores dos ciclos para cada filtro e para cada optimização estão representados na Tabela 2.
O-‐0 O-‐1 O-‐2
Selecção filtros 31 15 11 Negativo 2.655.013 82.842 82.706
Equalização 466.005 202.527 218.902 Emboss 18.527.457 6.900.777 5.446.622
Histograma 1.163.504 354.945 Software: 356.590 VHDL: 195.234
Tudo 20.888.512 7.744.879 7.421.675 Tabela 2 -‐ Optimizações das compilações e correspondente número de ciclos para cada um dos
filtros de processamento.
O histograma em software com optimizações normais (O-‐2) executa a função do
histograma em 356590 ciclos, com o histograma pré calculado em hardware a função executa 195234 ciclos isto representa uma melhoria de aproximadamente 1.8.
Cada nível de optimização apresenta melhorias na performance dos algoritmos. O delta das melhorias apresenta-‐se maior entre compilação sem optimização e optimização baixa (O-‐1). Entre O-‐1 e O-‐2 os algoritmos mais simples como o negativo e histograma não apresentam melhorias significativas enquanto que o ganho em performance dos mais complexos é bastante reduzido.
Em termos qualitativos e com base nas imagens obtidas do processamento é
possível chegar a algumas conclusões sobre o desempenho do sistema. A qualidade do emboss é devido á falta de contraste da imagem base. Isto pode ser
corrigido com a equalização. O histograma não apresenta uma curva completamente representativa da imagem
porque a imagem só têm uma resolução horizontal de 128 pixéis. A interpolação reduz cada barra a ser a soma de duas intensidades adjuntas.
O ruído na imagem afecta os resultados a equalização criando zonas de contraste artificiais.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
17
10. Conclusão do Projecto Neste projecto desenvolveram-‐se as bases de um sistema de captura e
processamento de imagem em tempo real. Destacam-‐se algumas conclusões e limitações de sistemas deste tipo e consoante o hardware utilizado. Verifica-‐se que o microblaze não é o processador indicado para fazer operações de cálculo pesados. A vantagem que traz é a facilidade de interligar blocos de processamento dedicados como é o caso do histograma. Como o nome da aplicação implica o MB serve só como um processador embebido destinado a controlo de funções e lógica.
No propósito deste sistema, que é a realização do filtro emboss, destacou-‐se uma forte influência da baixa qualidade das imagens capturadas pela câmara na qualidade da imagem processada. A existência de muito ruído e de um baixo contraste na imagem capturada implica que no filtro de emboss esses defeitos sejam acentuados.
A baixa resolução da imagem utilizada, somente 128x64, limita muito aquilo que se observa. Também associado ao depth of field da câmara, é difícil discernir exactamente o que se está a capturar quando os objectos estão muito próximos da câmara.
Acreditamos que para se obter um melhor filtro de emboss é vantajoso utilizar operações de vírgula flutuante para calcular a convolução e consequente escala. Utilizar uma escala inteira impede obter uma resolução precisa do resultado da convolução e um contraste de emboss reduzido.
No caso do histograma verificou-‐se que a câmara não apresenta todos os níveis de cinzento. Os dois valores mais pretos e os dois valores mais brancos não são capturados. Uma das alterações possíveis de se realizar no histograma é permitir que níveis de cinzento que tenham um número reduzido de ocorrências e muito inferiores ao número máximo de ocorrências não sejam cortadas. Deve ser sempre repreentado um traço para o correspondente nível caso existam pixéis que contenham esse nível de cinzento. Devido ao escalonamento no histograma, que faz com que o valor máximo toque no limite superior da imagem, pode ocorrer que um nível de cinzentos onde haja pouca ocorrência de pixéis nem seja representado na imagem.
É de notar que as figuras apresentadas neste relatório são fotografias retiradas do sistema em funcionamento com a câmara apontada para uma projecção da imagem frequentemente utilizada para demonstração de filtros a funcionar. Estas figuras não apresentam a melhor qualidade de imagem que os algoritmos implementados conseguem apresentar, no entanto as imagens são genuínas. Esta baixa qualidade deve-‐se à reduzida qualidade tanto da câmara que captura as imagens para processamento como da câmara fotográfica utilizada.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
18
7. Bibliografia Microblaze Reference Guide Datasheet do Xilinx Spartan 3 FPGA Teoria sobre as convoluções: http://fourier.eng.hmc.edu/e161/lectures/convolution/index.html http://www.songho.ca/dsp/convolution/convolution.html Exemplos de matrizes de convoluçãoo: http://docs.gimp.org/en/plug-‐in-‐convmatrix.html Documentação dos drivers para o software Xilinx:
http://www.cs.washington.edu/education/courses/csep567/04sp/pdfs/xilinx_drivers.pdf
8. Anexos Como anexo é enviado por email um ficheiro zip com o projecto do sistema. Está
incluído o executável para o Xilinx contendo a descrição hardware da FPGA e o software para o processador criado.
Sistemas Electrónicos de Computadores – Processamento de Imagem com FPGA
19
Esta página foi deixada intencionalmente em branco