SEC Relatorio FPGA

19
Sistemas Electrónicos de Computadores (20112012 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

description

Enunciado como implementar Rato Otico

Transcript of SEC Relatorio FPGA

Page 1: 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      

Page 2: SEC Relatorio FPGA

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  

 

Page 3: SEC Relatorio FPGA

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.          

     

Page 4: SEC Relatorio FPGA

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.  

     

Page 5: SEC Relatorio FPGA

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]++;  }  

Page 6: SEC Relatorio FPGA

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  

Page 7: SEC Relatorio FPGA

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.  

Page 8: SEC Relatorio FPGA

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  

Page 9: SEC Relatorio FPGA

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.  

Page 10: SEC Relatorio FPGA

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.  

   

Page 11: SEC Relatorio FPGA

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]];  }  

Page 12: SEC Relatorio FPGA

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.  

Page 13: SEC Relatorio FPGA

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.  

Page 14: SEC Relatorio FPGA

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.    

   

Page 15: SEC Relatorio FPGA

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();  

}  

Page 16: SEC Relatorio FPGA

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.    

     

Page 17: SEC Relatorio FPGA

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.  

   

   

Page 18: SEC Relatorio FPGA

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.    

Page 19: SEC Relatorio FPGA

Sistemas  Electrónicos  de  Computadores  –  Processamento  de  Imagem  com  FPGA  

  19  

Esta  página  foi  deixada  intencionalmente  em  branco