ambiente de suporte ao ensino de processamento de imagens …alexgs/tese/silva.pdf · a linguagem...

Universidade Estadual de Campinas - UNICAMPFaculdade de Engenharia Eletrica e de Computacao

Ambiente de Suporte ao Ensino de

Processamento de Imagens Usando a

Linguagem Python

Autor: Alexandre Goncalves SilvaOrientador: Prof. Dr. Roberto de Alencar Lotufo

Dissertacao de Mestrado apresentada a Fa-culdade de Engenharia Eletrica e de Computacaocomo parte dos requisitos para obtencao do tıtulode Mestre em Engenharia Eletrica. Area de con-centracao: Engenharia de Computacao.

Banca ExaminadoraProf. Dr. Arnaldo de Albuquerque Araujo ICEx/DCC/UFMGProf. Dr. Clesio Luiz Tozzi DCA/FEEC/UNICAMP

Fevereiro de 2003Campinas, SP - Brasil

FICHA CATALOGRAFICA ELABORADA PELA

BIBLIOTECA DA AREA DE ENGENHARIA - BAE - UNICAMP

Silva, Alexandre GoncalvesSi38a Ambiente de suporte ao ensino de processamento de

imagens usando a linguagem Python / AlexandreGoncalves Silva.--Campinas, SP: [s.n.], 2003.

Orientador: Roberto de Alencar Lotufo.Dissertacao (mestrado) - Universidade Estadual de

Campinas, Faculdade de Engenharia Eletrica e deComputacao.

1. Processamento de imagens. 2. Educacao. 3.Engenharia – Estudo e ensino. 4. Software –Desenvolvimento. 5. Software livre. I. Lotufo, Robertode Alencar. II. Universidade Estadual de Campinas.Faculdade de Engenharia Eletrica e de Computacao. III.Tıtulo.

Resumo

Este trabalho consiste no estudo, desenvolvimento e implementacao deuma caixa de ferramentas de processamento de imagens usando a linguagemPython de programacao e o pacote Numerical Python. A caixa de ferramen-tas foi desenvolvida dentro do projeto Adesso. Este e uma colecao de fer-ramentas baseada na tecnologia XML que auxilia a programacao, a escritade documentacao e a inteface de bibliotecas C para plataformas comumenteutilizadas. No Adesso, havia originalmente suporte as linguagens de pro-gramacao MATLAB e Tcl/Tk. Este trabalho o estende de modo que suportea linguagem Python. A caixa de ferramentas de processamento de imagens edisponibilizada como “codigo aberto”, segue a mesma licenca de distribuicaoda linguagem Python e do pacote Numerical, e e util ao ensino, pesquisa edesenvolvimento de aplicacoes finais.

III

IV RESUMO

Abstract

This work consists in the study, development and implementation of atoolbox for image processing written in the Python programming languageand in the Numerical Python package. The toolbox was developed using theAdesso project. Adesso is a collection of tools based on the XML technology,which helps the programming, the writing of the documentation and the in-terfacing of C libraries to standard platforms. Adesso originally supportedMATLAB and Tcl/Tk programming languages. This work has extended Ad-esso to support the Python language. The image processing toolbox is avail-able as “open source”, following the same distribution license of the Pythonlanguage and the Numerical package. The toolbox is useful for education,research and development of final applications.

V

VI ABSTRACT

A minha avo que, enquanto presente,nos fazia vibrar com sua mais profunda serenidade.

Agradecimentos

Nao poderia deixar de mencionar aqui a figura de meus pais: Olenir eElenir. A semelhanca dos nomes nao e maior que a do cuidado que ambos tempara com os filhos. Mesmo correndo o risco de me tornar repetitivo nao mecanso de lhes agradecer muito. Mais que um solido alicerce, proporcionaram-me oportunidades! Sem as mesmas, fico imaginando... O que seria entao?

Gostaria de externar minha admiracao pelo modo como se procedeu aorientacao a este trabalho. Agradeco ao Prof. Lotufo por sua competenciaem trilhar o caminho do bom-senso, criatividade quase que contagiante, ca-pacidade em se desvencilhar dos problemas, e dedicacao sempre prontamentedispensada.

Agradeco ao Rubens do CenPRA por solucionar sempre nossas duvidasquando o assunto era: “Ambiente para Desenvolvimento de SoftwareCientıfico” (Adesso). Por ser nossa seguranca em muitos pontos crıticos.

Agradeco tambem aos meus familiares, aos amigos da pequena grandeApucarana, meu irmao de sangue Giuliano, meus irmaos de pesquisa - Andre,Francisco, Guilherme, Jane, Marco, Ricardo, Romaric e Wellington - portoda forca prestada nesta caminhada. Aos camaradas - Alex, Carlos, Fran-klin, Ivana, Luiz, Maurıcio e Rangel - por todas as divertidas “intrigas” quedeixaram minha vida mais branda nas horas difıceis.

A minha queria Letıcia que, mesmo relutante, acabou por me permitirincluir seu nome aqui. Agradeco suas doces palavras que me confortaram eme fizeram forte antes da defesa...

Agradeco a FAPESP e a FAEP pelo incentivo a pesquisa e, em especial,pelo inestimavel suporte a esta realizacao.

Enfim, agradeco a todos que, de alguma forma, participaram deste tra-balho. Uma ideia, um palpite por mais despretensiosos que parecessem,sem duvida, foram decisivos em particularidades do projeto e ate mesmo emcapıtulos completos deste texto.

X AGRADECIMENTOS

Sumario

Sumario XI

Lista de Figuras XVII

Lista de Tabelas XIX

1 Introducao 11.1 Ferramentas Existentes . . . . . . . . . . . . . . . . . . . . . . 21.2 Motivacao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3 A Linguagem Python . . . . . . . . . . . . . . . . . . . . . . . 41.4 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.5 Estruturacao da Dissertacao . . . . . . . . . . . . . . . . . . . 6

2 Modelo de Programacao 92.1 Processamento de Imagens . . . . . . . . . . . . . . . . . . . . 10

2.1.1 Representacao de Imagens . . . . . . . . . . . . . . . . 102.2 Modelo de Programacao . . . . . . . . . . . . . . . . . . . . . 142.3 Desempenho . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3 Ambiente de Desenvolvimento 193.1 Programacao em Python . . . . . . . . . . . . . . . . . . . . . 21

3.1.1 Pacote Numerical . . . . . . . . . . . . . . . . . . . . . 223.1.2 Interface Grafica . . . . . . . . . . . . . . . . . . . . . 263.1.3 Formatos de Arquivo . . . . . . . . . . . . . . . . . . . 28

3.2 O Sistema Adesso . . . . . . . . . . . . . . . . . . . . . . . . . 293.2.1 Estruturacao em XML . . . . . . . . . . . . . . . . . . 303.2.2 Processo de Transformacao . . . . . . . . . . . . . . . . 323.2.3 Geracao de Codigo . . . . . . . . . . . . . . . . . . . . 33

XI

XII SUMARIO

3.2.4 Geracao de Wrapper . . . . . . . . . . . . . . . . . . . 413.2.5 Geracao de Setup . . . . . . . . . . . . . . . . . . . . . 453.2.6 Geracao de Documentacao . . . . . . . . . . . . . . . . 46

4 Resultados 514.1 Caixa de Ferramentas . . . . . . . . . . . . . . . . . . . . . . . 514.2 Corretor Automatico . . . . . . . . . . . . . . . . . . . . . . . 564.3 Avaliacao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594.4 Morfologia Matematica . . . . . . . . . . . . . . . . . . . . . . 614.5 Python x MATLAB . . . . . . . . . . . . . . . . . . . . . . . . 62

5 Consideracoes Finais 675.1 Conclusoes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675.2 Trabalhos Futuros . . . . . . . . . . . . . . . . . . . . . . . . . 69

Referencias Bibliograficas 71

Trabalhos Publicados 75

A Implementacoes de MSE 77A.1 Em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77A.2 Em Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77A.3 Em Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78A.4 Em MATLAB . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

B Exemplo de Folha de Estilo 79

C Functions 83C.1 Image Creation . . . . . . . . . . . . . . . . . . . . . . . . . . 83

C.1.1 iabwlp . . . . . . . . . . . . . . . . . . . . . . . . . . 83C.1.2 iacircle . . . . . . . . . . . . . . . . . . . . . . . . . . 84C.1.3 iacomb . . . . . . . . . . . . . . . . . . . . . . . . . . 85C.1.4 iacos . . . . . . . . . . . . . . . . . . . . . . . . . . . 86C.1.5 iagaussian . . . . . . . . . . . . . . . . . . . . . . . . 87C.1.6 ialog . . . . . . . . . . . . . . . . . . . . . . . . . . . 88C.1.7 iaramp . . . . . . . . . . . . . . . . . . . . . . . . . . 89C.1.8 iarectangle . . . . . . . . . . . . . . . . . . . . . . . . 90

C.2 Image Information and Manipulation . . . . . . . . . . . . . . 91C.2.1 iacrop . . . . . . . . . . . . . . . . . . . . . . . . . . 91

SUMARIO XIII

C.2.2 iaind2sub . . . . . . . . . . . . . . . . . . . . . . . . 91C.2.3 iameshgrid . . . . . . . . . . . . . . . . . . . . . . . . 92C.2.4 ianeg . . . . . . . . . . . . . . . . . . . . . . . . . . . 93C.2.5 ianormalize . . . . . . . . . . . . . . . . . . . . . . . 93C.2.6 iapad . . . . . . . . . . . . . . . . . . . . . . . . . . . 94C.2.7 iaroi . . . . . . . . . . . . . . . . . . . . . . . . . . . 95C.2.8 iasub2ind . . . . . . . . . . . . . . . . . . . . . . . . 95C.2.9 iatile . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

C.3 Image file I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . 96C.3.1 iaread . . . . . . . . . . . . . . . . . . . . . . . . . . 96C.3.2 iawrite . . . . . . . . . . . . . . . . . . . . . . . . . . 97

C.4 Contrast Manipulation . . . . . . . . . . . . . . . . . . . . . . 97C.4.1 iaapplylut . . . . . . . . . . . . . . . . . . . . . . . . 97C.4.2 iacolormap . . . . . . . . . . . . . . . . . . . . . . . . 99

C.5 Color Processing . . . . . . . . . . . . . . . . . . . . . . . . . 99C.5.1 iahsv2rgb . . . . . . . . . . . . . . . . . . . . . . . . 99C.5.2 iargb2hsv . . . . . . . . . . . . . . . . . . . . . . . . 100C.5.3 iargb2ycbcr . . . . . . . . . . . . . . . . . . . . . . . 101C.5.4 iatcrgb2ind . . . . . . . . . . . . . . . . . . . . . . . . 102C.5.5 iaycbcr2rgb . . . . . . . . . . . . . . . . . . . . . . . 102

C.6 Geometric Manipulations . . . . . . . . . . . . . . . . . . . . . 103C.6.1 iaffine . . . . . . . . . . . . . . . . . . . . . . . . . . 103C.6.2 iageorigid . . . . . . . . . . . . . . . . . . . . . . . . 104C.6.3 iaptrans . . . . . . . . . . . . . . . . . . . . . . . . . 105C.6.4 iaresize . . . . . . . . . . . . . . . . . . . . . . . . . . 106

C.7 Image Transformation . . . . . . . . . . . . . . . . . . . . . . 107C.7.1 iadct . . . . . . . . . . . . . . . . . . . . . . . . . . . 107C.7.2 iadctmatrix . . . . . . . . . . . . . . . . . . . . . . . 107C.7.3 iadft . . . . . . . . . . . . . . . . . . . . . . . . . . . 108C.7.4 iadftmatrix . . . . . . . . . . . . . . . . . . . . . . . . 109C.7.5 iafftshift . . . . . . . . . . . . . . . . . . . . . . . . . 110C.7.6 iahaarmatrix . . . . . . . . . . . . . . . . . . . . . . . 110C.7.7 iahadamard . . . . . . . . . . . . . . . . . . . . . . . 111C.7.8 iahadamardmatrix . . . . . . . . . . . . . . . . . . . . 111C.7.9 iahwt . . . . . . . . . . . . . . . . . . . . . . . . . . . 112C.7.10 iaidct . . . . . . . . . . . . . . . . . . . . . . . . . . . 113C.7.11 iaidft . . . . . . . . . . . . . . . . . . . . . . . . . . . 113C.7.12 iaifftshift . . . . . . . . . . . . . . . . . . . . . . . . . 114

XIV SUMARIO

C.7.13 iaihadamard . . . . . . . . . . . . . . . . . . . . . . . 115C.7.14 iaihwt . . . . . . . . . . . . . . . . . . . . . . . . . . 115C.7.15 iaisdftsym . . . . . . . . . . . . . . . . . . . . . . . . 116

C.8 Image Filtering . . . . . . . . . . . . . . . . . . . . . . . . . . 116C.8.1 iacontour . . . . . . . . . . . . . . . . . . . . . . . . . 116C.8.2 iaconv . . . . . . . . . . . . . . . . . . . . . . . . . . 117C.8.3 ialogfilter . . . . . . . . . . . . . . . . . . . . . . . . . 118C.8.4 iapconv . . . . . . . . . . . . . . . . . . . . . . . . . . 119C.8.5 iasobel . . . . . . . . . . . . . . . . . . . . . . . . . . 121C.8.6 iavarfilter . . . . . . . . . . . . . . . . . . . . . . . . 122

C.9 Automatic Thresholding Techniques . . . . . . . . . . . . . . . 123C.9.1 iaotsu . . . . . . . . . . . . . . . . . . . . . . . . . . 123

C.10 Measurements . . . . . . . . . . . . . . . . . . . . . . . . . . . 123C.10.1 iacolorhist . . . . . . . . . . . . . . . . . . . . . . . . 123C.10.2 iahistogram . . . . . . . . . . . . . . . . . . . . . . . 124C.10.3 ialabel . . . . . . . . . . . . . . . . . . . . . . . . . . 124C.10.4 iarec . . . . . . . . . . . . . . . . . . . . . . . . . . . 125C.10.5 iastat . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

C.11 Halftoning Approximation . . . . . . . . . . . . . . . . . . . . 127C.11.1 iadither . . . . . . . . . . . . . . . . . . . . . . . . . 127C.11.2 iafloyd . . . . . . . . . . . . . . . . . . . . . . . . . . 127

C.12 Visualization . . . . . . . . . . . . . . . . . . . . . . . . . . . 128C.12.1 iadftview . . . . . . . . . . . . . . . . . . . . . . . . . 128C.12.2 iagshow . . . . . . . . . . . . . . . . . . . . . . . . . 129C.12.3 iaisolines . . . . . . . . . . . . . . . . . . . . . . . . . 129C.12.4 ialblshow . . . . . . . . . . . . . . . . . . . . . . . . . 129C.12.5 iaplot . . . . . . . . . . . . . . . . . . . . . . . . . . . 130C.12.6 iashow . . . . . . . . . . . . . . . . . . . . . . . . . . 131C.12.7 iasplot . . . . . . . . . . . . . . . . . . . . . . . . . . 132

C.13 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133C.13.1 iaerror . . . . . . . . . . . . . . . . . . . . . . . . . . 133C.13.2 iahelp . . . . . . . . . . . . . . . . . . . . . . . . . . 133C.13.3 iatype . . . . . . . . . . . . . . . . . . . . . . . . . . 134C.13.4 iaunique . . . . . . . . . . . . . . . . . . . . . . . . . 135

D Lessons 137D.1 iaconvteo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137D.2 iacorrdemo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

SUMARIO XV

D.3 iadftdecompose . . . . . . . . . . . . . . . . . . . . . . . . . 140D.4 iadftexamples . . . . . . . . . . . . . . . . . . . . . . . . . . 140D.5 iadftmatrixexamples . . . . . . . . . . . . . . . . . . . . . . . 142D.6 iadftscaleproperty . . . . . . . . . . . . . . . . . . . . . . . . 142D.7 iagenimages . . . . . . . . . . . . . . . . . . . . . . . . . . . 144D.8 iahisteq . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147D.9 iahotelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148D.10 iainversefiltering . . . . . . . . . . . . . . . . . . . . . . . . . 152D.11 iait . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154D.12 iamagnify . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157D.13 iaotsudemo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

XVI SUMARIO

Lista de Figuras

2.1 Nıveis de programacao de uma ferramenta usual de processa-mento de imagens. . . . . . . . . . . . . . . . . . . . . . . . . 10

2.2 Representacao de imagens digitais em nıveis de cinza. . . . . . 112.3 Representacao de imagens digitais multibanda. . . . . . . . . . 122.4 Imagem visualizada em diferentes mapas de cores. . . . . . . . 132.5 Algoritmos de varredura explıcita e implıcita para o calculo

do MSE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.6 Exemplo para se gerar uma imagem em forma de xadrez por

manipulacao matricial. . . . . . . . . . . . . . . . . . . . . . . 162.7 Algoritmo de convolucao com reducao de iteracoes. . . . . . . 18

3.1 Modulo com sete funcoes diferentes para se gerar uma mesmaimagem em forma de xadrez. . . . . . . . . . . . . . . . . . . . 24

3.2 Script de teste de exibicao de imagem e grafico. . . . . . . . . 273.3 Esquema de transformacao do Sistema Adesso. . . . . . . . . . 293.4 Estrutura XML do Adesso. . . . . . . . . . . . . . . . . . . . . 303.5 Exemplo de estrutura XML para descricao de uma funcao. . . 313.6 Exemplo de codigo-fonte Python gerado automaticamente. . . 343.7 Exemplo de estrutura XML para descricao de uma demons-

tracao. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363.8 Codigo-fonte de demonstracao gerado automaticamente. . . . 373.9 Exemplo de saıda gerada quando na execucao de uma demons-

tracao. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383.10 Exemplo de testsuite gerado automaticamente. . . . . . . . . . 403.11 Modelo de construcao de um modulo built-in. . . . . . . . . . 413.12 Exemplo de typemap para o wrapper de uma funcao de soma

de dois inteiros. . . . . . . . . . . . . . . . . . . . . . . . . . . 433.13 Estruturas PyArrayObject e adimage. . . . . . . . . . . . . . 443.14 Modelo de construcao do setup.py. . . . . . . . . . . . . . . . 46

XVII

XVIII LISTA DE FIGURAS

3.15 Documentacao HTML gerada automaticamente. . . . . . . . . 48

4.1 Exemplo de uso da caixa de ferramentas no IDLE Python. . . 554.2 Esquema do corretor automatico na modalidade de “correcao”. 574.3 Ambiente de submissao e visualizacao de resultados. . . . . . . 584.4 Aplicacao de segmentacao de microestruturas do concreto. . . 624.5 Comparacoes de desempenho de funcoes built-in entre Python

e MATLAB. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644.6 Comparacoes de desempenho de funcoes ia636 entre Python

e MATLAB. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

5.1 Calculo on line do filtro de media usando CGI/Python e acaixa de ferramentas ia636. . . . . . . . . . . . . . . . . . . . 70

Lista de Tabelas

2.1 Comparacao de tempos medios (Sun Ultra 60) para o calculodo MSE entre duas imagens coloridas 256x256. . . . . . . . . . 15

2.2 Tempos calculados (Pentium 4-1.5GHz) para duas imple-mentacoes diferentes de um filtro de media sobre uma imagemde 256x256. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3.1 Quadro resumo de algumas estruturas built-in. . . . . . . . . . 23

4.1 Algumas diferencas de sintaxe entre Numerical Python e MA-TLAB. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

4.2 Avaliacao do ambiente de suporte a processamento de imagens. 60

XIX

XX LISTA DE TABELAS

Capıtulo 1

Introducao

“...Costumava se distrair realizando pequenos consertos

domesticos: uma boia de descarga, a bucha de uma torneira, um

fusıvel queimado. Dispunha para isso da necessaria habilidade

e de uma preciosa caixa de ferramentas em que ninguem mais

podia tocar. Aprendi com ele como e indispensavel, para a boa

ordem da casa, ter a mao pelo menos um alicate e uma chave de

fenda...”

Como Dizia Meu Pai, Fernando Sabino

Com a ampliacao de formas de aquisicao de imagens, poder crescente de

processamento dos computadores e aprimoramento de ferramentas computa-

cionais, o processamento digital de imagens se configura entre as principais

estrategias para tratar certos problemas em areas como medicina, biologia,

astronomia, automacao industrial, engenharia, geologia, agronomia, artes,

entre outras. Para imagens medicas, por exemplo, alem do tradicional raio-

X, ha tambem, hoje em dia, a tomografia computadorizada e a ressonancia

1

2 CAPITULO 1. INTRODUCAO

magnetica que geram imagens com dados e resolucoes diversas. O tipo de

informacao potencial registrada em uma imagem e importante e pode deter-

minar se uma aplicacao sera ou nao bem sucedida. Ainda na area medica,

como exemplo de aplicacao, pode-se citar a caracterizacao de tumores. Neste

caso, uma ferramenta mais objetiva (desprovida totalmente ou parcialmente

de interferencia humana) pode auxiliar o medico em seu diagnostico.

O foco do presente trabalho esta na escolha de plataformas de desenvol-

vimento de software cientıfico consideradas promissoras, definicao e imple-

mentacao de um conjunto de algoritmos tradicionais de processamento de

imagens, e organizacao sistematica de toda esta informacao de forma a mini-

mizar o custo de manutencao e criacao de programas e documentacao. Au-

xiliar o aprendizado dos assuntos referentes a disciplina de “Processamento

de Imagens” e o principal resultado, mas o ambiente construıdo tambem e

apto a ser utilizado em varias instancias de pesquisa e aplicacao.

1.1 Ferramentas Existentes

Existem diversas ferramentas computacionais apropriadas ao processa-

mento de imagens, tanto comerciais como gratuitas. Podemos citar o Khoros,

MATLAB [9], Mathematica, VisiLog, PV-WAVE, AVS, IDL, ImageMagik, e

o esforco nacional PhotoPixJ [1], entre outras [23].

O DCA-FEEC-Unicamp adotou, no perıodo de 1991 a 1997, a plata-

forma Khoros para ensino das disciplinas de pos-graduacao, para pesquisa e

aplicacoes. O Khoros e um ambiente completo de processamento de imagens

consistindo em uma interface de programacao visual bastante atrativa para

os iniciantes na area. Suas principais vantagens eram o fato de ser gratuito,

ter o codigo fonte disponıvel, oferecer um sistema de ajuda de autoria de

software, permitindo sua extensao para novas funcoes dentro do contexto

de caixa de ferramentas (toolboxes). Sua adocao pela Unicamp teve uma

grande influencia em diversos grupos de pesquisa do Brasil e do exterior. No

1.1. FERRAMENTAS EXISTENTES 3

DCA foram desenvolvidas tres toolboxes: V3DTOOLS de processamento e

visualizacao tridimensional [19], MMACH de Morfologia Matematica [4] e

DIPCOURSE de ensino de processamento de imagens [15, 17]. Este ultimo

foi o primeiro curso de processamento de imagens disponıvel na Internet.

Porem, o grupo de desenvolvimendo do Khoros nao acompanhou o avanco

tecnologico de software e, ao mesmo tempo, deixou de ser gratuito. Como

consequencia, o mesmo deixou de ser adotado no DCA como ferramenta

preferencial, dando lugar ao MATLAB1. Para o MATLAB tambem ja fo-

ram desenvolvidas algumas toolboxes, sendo uma delas repassada a industria

dentro do projeto Softex [27].

Baseado na experiencia de uso de duas plataformas distintas, pode-se di-

zer que as mesmas apresentam caracterısticas muito contrastantes, pois os

pontos mais fortes de uma sao os mais fracos de outra e vice-versa. Como

desvantagem do Khoros pode-se citar pouca documentacao, certa dificuldade

de instalacao, dificuldade de criacao de novas funcoes, e de ser dedicado a

problemas de processamento de imagens, apesar dos esforcos do grupo em

considera-lo um ambiente generico de desenvolvimento de software. Ja o MA-

TLAB e um ambiente generico de computacao cientıfica muito difundido nos

cursos de Engenharia, tem uma linguagem matricial extremamente simples,

compacta, muito proxima da linguagem matematica e possui uma grande

comunidade sendo frequentemente utilizado na descricao de algoritmos de

computacao cientıfica. Tem como maior desvantagem, entretanto, o seu alto

custo. Poucas instituicoes tem condicoes de adquiri-lo. Uma outra desvan-

tagem e a falta de ferramentas de autoria de caixas de ferramentas. Apesar

de ser muito facil criar um conjunto de funcoes voltadas a um problema, nao

existe nenhum suporte para a geracao de documentacao ou gerenciamento

das implementacoes.

1http://www.mathworks.com


1.2 Motivacao

E intencao do grupo desenvolver, a longo prazo, um ambiente compu-

tacional que contenha o melhor das plataformas Khoros e MATLAB. Neste

sentido ja existe o esforco associado ao projeto Adesso [21, 7], em cooperacao

com o CenPRA2, que consiste de um ambiente de autoria de software de

computacao cientıfica. O estagio atual do projeto, baseado na tecnologia

XML [31] contempla o suporte a geracao de documentacao e de codigo de

interface de bibliotecas computacionais. Havia ate entao o suporte a inter-

face automatica para as plataformas MATLAB e Tcl/Tk [34]. Este trabalho

detalha implementacoes similares feitas com o intuito de se gerar suporte

tambem para a linguagem Python e reforca, desta forma, a generalidade do

sistema.

1.3 A Linguagem Python

Recentemente, a linguagem Python [24, 20] vem mostrando um cresci-

mento muito grande, principalmente na comunidade academica, como sendo

uma linguagem interpretada bastante moderna, com conceitos de orientacao

a objetos e extensibilidade muito apurados. A linguagem foi concebida pelo

holandes Guido van Rossum e seu desenvolvimento teve inıcio em 1990, no

CWI, em Amsterda. O conjunto de entidades e pessoas ligadas a sua manu-

tencao e aprimoramento, sobretudo via Internet, formam a Python Software

Activity (PSA). Python e o nome popular dado a uma grande cobra qualquer,

mas o nome da linguagem e inspirado no tıtulo do programa humorıstico de

TV “Monty Python’s Flying Circus”.

Python apresenta semantica dinamica, um moderno mecanismo de tra-

tamento de erros e excecoes, flexibilidade no tratatamento de argumentos.

Possui uma forma eficiente de acesso e reutilizacao de codigo com o uso dos

2Centro de Pesquisas Renato Archer - Campinas - SP

1.3. A LINGUAGEM PYTHON 5

chamados “modulos”, coleta de lixo automatica, recursos avancados de ma-

nipulacao de textos, listas e dicionarios. Em Python, diferentemente de C++

ou Java, as funcoes sao tratadas como objetos, caracterıstica de linguagens de

programacao funcional como Lisp3. Por ser programado em C, ser livremente

distribuıdo e ter codigo aberto, Python oferece grande portabilidade.

Python, em sua versao 1.5.2, de 1999, integrante de varias distribuicoes

Linux, ja incluıa mais de 140 modulos nativos. Como ilustracao, pode-se

destacar os modulos os e sys para funcionalidades de sistema, cgi para pro-

gramacao de paginas dinamicas para Internet, ftplib para montagem de

scripts para interacao com servidores FTP, gzip para leitura e escrita de ar-

quivos comprimidos, math para utilizacao de funcoes matematicas, re para

busca de texto com expressoes regulares, string para operacoes com strings ,

time para obtencao de hora atual e conversao de formatos de data, xmllib

para interpretacao de arquivos em formato XML, sockets, manipulacao de

arquivos de entrada e saıda. Inumeros outros modulos, entre administracao

de sistemas, opcoes diversas de interfaces graficas com usuario (GUI), script-

ing para Internet, programacao de banco de dados, programacao cientıfica,

inteligencia artificial, graficos, CORBA, podem ser encontrados a partir do

site oficial4, quase todos livres e gratuitos. Em especial, ha um pacote de

suporte a computacao cientıfica denominado Numerical5 [3].

O Numerical tambem segue a linha “Open Source”, tem parte de suas

funcoes (crıticas em desempenho) programadas em C, e estende o Python de

forma simples e direta, implementando um eficiente modelo de matriz multi-

dimensional. Os modulos do Numerical foram projetados sob forte influencia

da famılia de linguagens APL, Basis, MATLAB, FORTRAN, S e S+, entre

outras. Desta forma, esta se tornando muito atrativo o uso do Python, as-

sociado a este pacote numerico e ao ambiente Adesso de autoria de software

cientıfico. Acredita-se ser possıvel dar um grande passo no sentido de se obter

3http://www.lisp.org4http://www.python.org5http://www.pfdubois.com/numpy


um sistema que agregue as vantagens dos sistemas Khoros e MATLAB.

1.4 Objetivos

O objetivo principal deste trabalho foi o desenvolvimento de uma caixa

de ferramentas para processamento de imagens que possa ser utilizada em

ensino e pesquisa. Para atingir este objetivo, o sistema Adesso, que serviu de

suporte para o desenvolvimento da caixa de ferramentas, foi estendido para

suportar a linguagem Python, tanto na geracao de codigo como na geracao

de documentacao. Adicionalmente, foi desenvolvido um sistema de entrega

via Internet, de relatorios e correcao automatica de programas feitos em Py-

thon para apoio ao uso da caixa de ferramentas em cursos de processamento

de imagens. O objetivo final e ter um conjunto de ferramentas totalmente

gratuito, de facil instalacao, multiplataforma e, sobretudo, de rapida apren-

dizagem e com programacao simplificada. E ainda, baseado em Python,

uma linguagem generica bem projetada que oferece suporte nativo as mais

diversas aplicacoes.

1.5 Estruturacao da Dissertacao

Este trabalho esta organizado da seguinte forma. O Capıtulo 2 ilustra o

modelo de programacao de algortimos de computacao cientıfica em lingua-

gens de scripting . O Capıtulo 3 descreve as ferramentas de desenvolvimento

e a forma como se da a producao de software. Neste capıtulo, se encontra

uma das tres contribuicoes principais do presente trabalho: o desenvolvi-

mento de folhas de estilos para que o sistema Adesso pudesse suportar a

linguagem Python. O Capıtulo 4 mostra os sistemas gerados para o suporte

ao ensino de processamento de imagens e os principais resultados obtidos.

Neste capıtulo, se encontra a contribuicao principal do trabalho: as diver-

sas funcoes e demonstracoes constituindo o pacote de auxılio ao ensino de

1.5. ESTRUTURACAO DA DISSERTACAO 7

processamento de imagens. A outra contribuicao, tambem neste capıtulo

e o sistema on line completo de entrega, correcao, de estatıstica e geren-

ciamento de exercıcios Python/C/C++ de alunos. Por fim, conclusoes sao

apresentadas no Capıtulo 5.

Capıtulo 2

Modelo de Programacao

Para cada linguagem de programacao, e natural que haja uma serie de

vantagens e desvantagens [22]. Deve-se analisar os propositos de uma dada

aplicacao para adocao de uma ferramenta em particular. Uma linguagem de

sistema pode ser suficientemente eficiente conforme o grau de otimizacao que

os programas sofrem na compilacao. Considerando eficiencia, a programacao

em linguagem assembly seria uma otima opcao mas demanda muito tempo e

paciencia na codificacao. Por outro lado, programas extremamente simples,

em poucas linhas e com eficiencia computacional compatıvel ao assembly

podem ser elaborados em linguagens de mais alto nıvel.

Uma ferramenta computacional generica para processamento de imagens

generica usualmente oferece dois nıveis de programacao, associando facili-

dade de implementacao e desempenho. Procura-se ter entao uma linguagem

interpretada de scripting servindo de interface a uma biblioteca de alto de-

sempenho escrita em uma linguagem de mais baixo nıvel como C/C++ ou

Fortran. A Figura 2.1 ilustra esta arquitetura. Porem, normalmente a de-

manda de ferramentas diversas de processamento de imagens e muito grande,

sendo praticamente impossıvel oferecer um sistema completo ao usuario.

9

10 CAPITULO 2. MODELO DE PROGRAMACAO

LinguagemVisual

Linguagem deSistema Usuário

Figura 2.1: Nıveis de programacao de uma ferramenta usual de processa-mento de imagens.

2.1 Processamento de Imagens

As tecnicas de processamento de imagens, desenvolvidas ao longo do

tempo, apresentam duas facetas principais: uma de melhoramento da quali-

dade das informacoes, facilitando a observacao humana; a outra de permitir

a extracao de dados, de forma automatica ou semi-automatica, por uma

maquina. Uma das primeiras aplicacoes, nos anos 20, foi o melhoramento

de imagens de jornal transmitidas via cabo submarino entre Londres e New

York, alem da introducao do sistema Bartlane que reduziu o tempo de trans-

porte das imagens, atraves do oceano Atlantico, de mais de uma semana para

menos de tres horas [12]. Com o aprimoramento computacional (aquisicao,

armazenamento, capacidade de processamento, comunicacao e exibicao) e o

desenvolvimento de novos algoritmos, o tratamento digital de imagens sobre-

voa cada vez mais novas areas da ciencia, tornando-se, hoje em dia, muitas

vezes, procedimento padrao e ate mesmo transparente ao usuario.

2.1.1 Representacao de Imagens

Uma imagem digital monocromatica e uma funcao bidimensional de in-

tensidade da luz f(x, y), onde x e y denotam as coordenadas espaciais e o

valor de f , em qualquer ponto (x, y), e proporcional ao brilho (ou nıvel de

cinza) da imagem naquele ponto (pixel). A Figura 2.2 ilustra a representacao

de uma imagem. A Figura 2.2(a) mostra a convencao adotada, neste texto

e na programacao Python, para a direcao e sentido dos eixos x e y. A Fi-

2.1. PROCESSAMENTO DE IMAGENS 11

x

y

f(x,y)

Origem

(a) Representacao da funcaof(x, y), origem, direcao e sen-tido adotados para os eixos x ey da imagem.

(b) Exemplo de imagem digital emnıveis de cinza (cada pixel tem inten-sidade entre 0 e 255).

(c) Ilustracao dos valores dos nıveis decinza da regiao da orelha do camera

200 150 100 50

0

1

2

3

4

5

6

7 01

23

45

67

89

0

50

100

150

200

250

(d) Representacao do perfil to-pografico da regiao da orelha docamera.

Figura 2.2: Representacao de imagens digitais em nıveis de cinza.


banda 0

banda 2banda 1

banda n−1

Figura 2.3: Representacao de imagens digitais multibanda.

gura 2.2(b) exemplifica uma imagem digital com a indicacao de selecao de

uma pequena regiao da orelha do camera. Cada pixel da imagem, neste

exemplo, e representado por um inteiro sem sinal de 1 byte (8− bit), ou seja,

cada pixel pode assumir um valor entre 0 e 28 − 1. A Figura 2.2(c) ilustra

os valores dos nıveis de cinza da regiao selecionada e a Figura 2.2(d), o per-

fil topografico, sendo os vertices do grafico uma representacao dos pixels da

imagem nesta regiao.

Uma imagem multibanda consiste em se ter, para cada pixel (x, y), um

vetor (a0, a1, . . . , an−1), onde cada elemento ak, k ∈ [0, n − 1], apresenta um

nıvel de cinza. A Figura 2.3 ilustra esta representacao. Uma imagem colorida

e multibanda com k ∈ [0, 2]. Ha diversos modelos para representar imagens

coloridas, muitos deles baseado em luminancia (associado ao brilho da luz),

matiz (associado ao comprimento de onda dominante) e saturacao (associado

ao grau de pureza da matiz). Neste trabalho, as imagens coloridadas sao

armazenadas e exibidas no modelo RGB ou, de outra forma, a1 = R (banda

vermelha), a2 = G (banda verde) e a3 = B (banda azul). A maioria das

cores visıveis pode ser representada como uma combinacao destas tres cores

primarias. Normalmente, sao utilizados tres inteiros sem sinal, um para cada

banda, ou 3 bytes (24 − bit) para representar cada pixel .

2.1. PROCESSAMENTO DE IMAGENS 13

(a) Imagem original. (b) 8 intensidades. (c) 2 intensidades.

Figura 2.4: Imagem visualizada em diferentes mapas de cores.

Pode-se dizer que a representacao de cada pixel por um inteiro sem sinal

de 8−bit, em geral, e superior ao total de nıveis que a visao humana pode dis-

tinguir. Isto e verificado, por exemplo, na Figura 2.4. Apesar de um drastica

reducao dos 256 nıveis de cinza da imagem da Figura 2.4(a) para apenas

os 8 nıveis distintos (0, 36, 72, 109, 145, 182, 218 e 255) da Figura 2.4(b),

o resultado visual nao apresenta grandes diferencas. A percepcao humana,

no entanto, e mais apurada quando se trata de imagens coloridas. Ja na

Figura 2.4(c), o resultado e crıtico por se ter apenas dois nıveis (0 e 255)

para descrever a imagem original. Ainda neste exemplo, uma forma simples

de compressao da imagem original seria a representacao de cada pixel em

3 − bit para o primeiro caso e 1 − bit para o segundo.

Para efeito de programacao, verifica-se que a representacao de imagem se

ajusta a uma representacao comum de matriz bidimensional ou tridimensio-

nal de numeros, ou seja, com profundidade 1 em caso de imagens em nıveis

de cinza ou profundidade 3 (ou tres matrizes justapostas) em caso de imagens

coloridas.


Saída: valor do MSEEntrada: imagens f1 e f2 (de mesmas dimensões)

MSE = 0

Para todo j entre 0 e largura(f1)−1 faça: Para todo k entre 0 e 2 faça:

Varredura explícita:

MSE = MSE + (f1[i,j,k] − f2[i,j,k])^2MSE = MSE / (3*altura(f1)*largura(f1))

Varredura implícita:

MSE = (lineariza(f1) − lineariza(f2))^2

MSE = soma(MSE) / (3*altura(f1)*largura(f1))

Para todo i entre 0 e altura(f1)−1 faça:

Figura 2.5: Algoritmos de varredura explıcita e implıcita para o calculo doMSE.

2.2 Modelo de Programacao

Linguagens interpretadas como Python ou MATLAB tem excelente su-

porte a operacoes matriciais (condicao esperada em um sistema de proces-

samento de imagens) e sao apropriadas para construcao de prototipos, pois

nelas, em geral, o tempo de desenvolvimento de programas e consideravel-

mente mais curto. Porem, muitas vezes, nao se ajustam a implementacoes

que necessitam de iteracao excessiva.

A Tabela 2.1 compara os tempos para o calculo do MSE (Mean Square

Error ou Erro Medio Quadratico), entre duas imagens coloridas (256x256

pixels), em diferentes linguagens. Os algoritmos sao descritos na Figura 2.5

e as implementacoes podem ser vistas no Apendice A. A equacao adotada e

MSE =1

3NhNw

Nh−1∑

i=0

Nw−1∑

j=0

2∑

k=0

[

(f1(i, j, k) − f2(i, j, k))2]

onde f1 e f2 podem ser consideradas imagens de entrada, no modelo RGB,

de mesma dimensao NhxNwx3. Os testes notados por “explıcita” ilustram a

ineficiencia em se usar lacos iterativos de varredura explıcita em linguagens

interpretadas. Python implementa um codigo intermediario otimizado tor-

2.3. DESEMPENHO 15

TemposMATLAB (matricial) 0, 038s

C 0, 051s

Python (matricial) 0, 136s

Java 0, 198s

Python (explıcita) 4, 473s

MATLAB (explıcita) 14, 628s

Tabela 2.1: Comparacao de tempos medios (Sun Ultra 60) para o calculo doMSE entre duas imagens coloridas 256x256.

nando este tipo de implementacao consideravelmente mais rapido em relacao

ao MATLAB. Java, dita semi-interpretada por alguns autores, pela producao

de bytecode portavel, normalmente utiliza um vetor de inteiros (4 bytes)

na representacao de imagens. Cada byte determina um canal (Alpha, Red ,

Green, Blue). A manipulacao desta estrutura usando deslocamento de bits

e bastante eficiente mas, ainda assim, o tempo e quase 4 vezes superior a

implementacao em C. Os testes notados por “matricial” se aproveitam da

existencia de operadores matriciais das linguagens de scripting em questao.

Os operadores necessarios na programacao do MSE sao basicamente: soma

de todos elementos de uma matriz, subtracao de matrizes (pixel a pixel)

e quadrado de matrizes (pixel a pixel). Observa-se o ganho obtido no uso

destas funcionalidades. Neste caso, Python supera Java e a implementacao

MATLAB e ate mais eficiente que a adotada em C.

2.3 Desempenho

Esta secao introduz um modelo de programacao para que se possa con-

tornar o problema de desempenho em linguagens de scripting como Python e

MATLAB, de forma mais direta, ou seja, sem a necessidade de construcao de

uma API (vide Subsecao 3.2.4), sempre que houver a necessidade de imple-

mentacao de um programa para manipulacao de grandes conjuntos de dados

(como uma imagem).


(

1 1 . . . 12 2 . . . 2...

.... . .

...N N . . . N

+

1 2 . . . M

1 2 . . . M...

.... . .

...1 2 . . . M

)

% 2 =

0 1 0 1 . . .

1 0 1 0 . . .

0 1 0 1 . . ....

......

.... . .

xNxM yNxM zNxM

Figura 2.6: Exemplo para se gerar uma imagem em forma de xadrez pormanipulacao matricial.

Dada a facilidade de programacao, e interessante que a maioria dos al-

goritmos solicitados em uma disciplina de processamento de imagens seja

implementada diretamente em linguagens interpretadas de forma eficiente.

Para isto, deve-se evitar, sobretudo, programas com iteracao explıcita. A

ideia e proceder indiretamente toda iteracao necessaria, sempre que possıvel,

atraves de manipulacoes matriciais. Um exercıcio inicial, neste sentido, po-

deria ser a geracao de uma imagem 2-D, na qual os elementos justapostos se

alternam entre 0 e 1 em ambas direcoes. Ha diversos procedimentos para se

elaborar esta imagem em forma de xadrez. Pensando em termos de operacoes

matriciais pode-se propor a soma entre duas matrizes de malha de ındices

seguida pelo calculo do resto da divisao inteira por dois:

z(i, j) = (x(i, j) + y(i, j)) % 2

onde x(i, j) = i+1 e y(i, j) = j +1, para ∀i ∈ [0, N −1] e ∀j ∈ [0, M −1].

A Figura 2.6 ilustra esta operacao. Observe que tanto o operador “+”

(soma) como o operador “%” (resto da divisao inteira) devem estar presentes

na linguagem e se encarregar de fazer o calculo pixel a pixel . As matrizes x e

y podem ser facilmente e eficientemente construıdas (Numeric.indices em

Python; meshgrid em MATLAB). Desta mesma forma, pode-se sintetizar

uma imagem de cırculo, logaritmo, cossenoide 2-D, entre outros exemplos.

Outra abordagem pode ser considerada quando ha operacoes de vizi-

nhanca dada uma mascara de convolucao. A seguir, tem-se a equacao ado-

2.3. DESEMPENHO 17

Mascara Teste 1 Teste 23x3 22, 41s 0, 05s

5x5 61, 23s 0, 13s

7x7 119, 07s 0, 26s

Tabela 2.2: Tempos calculados (Pentium 4-1.5GHz) para duas imple-mentacoes diferentes de um filtro de media sobre uma imagem de 256x256.

tada para convolucao periodica bidimensional:

(f ∗(N,M) h)(x, y) =N−1∑

i=0

M−1∑

j=0

f(i, j)h(mod(x − i, N), mod(y − j, M))

onde mod(x, N) = x − Nb xNc, sendo as imagens f e h periodicas de

dimensao NxM .

Neste caso, e mais eficiente criar uma imagem aumentada auxiliar e trans-

ladar f em todas as posicoes da mascara h, calculando a soma acumulada do

produto destas translacoes por cada pixel da mascara. A Figura 2.7 ilustra

este algoritmo. A Tabela 2.2 mostra tempos calculados para duas imple-

mentacoes, em Python, de um filtro por convolucao. No Teste 1, e feita uma

varredura pixel a pixel com a utilizacao de quatro lacos iterativos (dois para

a imagem e dois para a mascara). Ja, no Teste 2, sao feitas translacoes na

imagem e sao usados dois lacos iterativos apenas para a mascara. Observa-se

a diferenca expressiva de tempo entre os metodos. Em se tratando do uso

de linguagens interpretadas, e importante ter em mente este modelo de pro-

gramacao, no qual um operador, sempre que houver, possa ser aplicado a um

grande conjunto de dados em uma unica vez. Na verdade, este ganho em

eficiencia vem justamente do fato destes operadores serem implementados

em linguagens de mais baixo nıvel.


rows = altura(f), cols = largura(f)hrows = altura(h), hcols = largura(h)

dr1 = inteiro((hrows−1)/2), dr2 = hrows−dr1dc1 = inteiro((hcols−1)/2), dc2 = hcols−dc1

// Criacao de uma matriz p aumentada:p = concatena_vertical( concatena_vertical(f[{−dr2+1..fim},{0..fim}], f), f[{0..dr1},{0..fim}] )p = concatena_horizontal( concatena_horizontal(p[{0..fim},{−dc2+1..fim}], p), p[{0..fim},{0..dc1}] )

g = cria_matriz_zeros(rows,cols)Para todo r entre 0 e hrows−1: Para todo c entre 0 e hcols−1: g = g + h[hrows−r−1,hcols−c−1] * p[{r..rows+r},{c..cols+c}]

Entrada: imagens f1 e f2Saída: imagem g

Figura 2.7: Algoritmo de convolucao com reducao de iteracoes.

Capıtulo 3

Ambiente de Desenvolvimento

A computacao cientıfica se caracteriza pelo uso de computadores para in-

vestigar modelos matematicos em ciencias e engenharia, alem de algumas das

ciencias sociais como economia. Sua importancia vem sendo impulsionada

pelo desenvolvimento de computadores modernos poderosos e ferramentas

de alta performance, de preferencia, faceis de serem utilizadas e modifica-

das. E desejavel tambem que a linguagem de desenvolvimento, apesar de

fundamentalmente aplicada a computacao cientıfica, seja de proposito ge-

ral, agregando funcionalidades de rede, interface grafica, entre outras, de

forma a nao impossibilitar a expansao do software produzido. Alem disto,

e importante que se tenha uma boa documentacao publicada na Internet

ou impressa para que a comunidade beneficiada primeiramente se identifique

com o produto e, apos isto, passe a divulga-lo e aprimora-lo atraves de contri-

buicoes. A documentacao deve tipicamente conter um manual de referencia

das ferramentas, um tutorial e um conjunto de demonstracoes. O manual

de referencia deve conter a descricao sintatica do comando ou funcao, exem-

plos ilustrativos, equacoes matematicas, referencias bibliograficas e descricao

do algoritmo utilizado. E imprescindıvel tambem haver correspondencia da

documentacao com as novas versoes do software.

O paradigma de nıveis de programacao da Figura 2.1 se aplica especial-

19

20 CAPITULO 3. AMBIENTE DE DESENVOLVIMENTO

mente bem ao desenvolvimento de software cientıfico onde a implementacao

de algoritmos quase sempre exige a utilizacao de linguagens de programacao

de sistemas. A confeccao de aplicacoes, entretanto, pode ser feita a partir

de linguagens de scripting ou programacao visual com grandes ganhos de

produtividade e facilidades de depuracao. Python e uma plataforma que dis-

ponibiliza interfaces de programacao bem definidas para a incorporacao de

extensoes escritas principalmente em C/C++. A criacao destas extensoes e

um processo mecanico que se torna muito trabalhoso a medida em que se

tem muitos componentes. Este tipo de situacao incentiva o uso da pratica

“copia e cola” pois a maioria dos programas possuem um gabarito a ser

seguido. E comum criar um novo componente a partir da copia de um com-

ponente similar e fazer as substituicoes necessarias. Esta pratica e uma das

maiores dificuldades encontradas por equipes de desenvolvimento de sofware

cientıfico. A pratica de “copia e cola” aumenta consideravelmente o numero

de linhas de programas, e uma fonte inerente de erros e faz com que o sis-

tema venha a apresentar uma manutencao muito cara para ser atualizado na

tentativa de seguir as tendencias tecnologicas. Automatizar estas geracoes

sistematicas de codigo e documentacao e um ponto extremamente valioso na

producao de software cientıfico.

Neste capıtulo, sera feita uma breve apresentacao de mecanismos de fun-

cionamento e sintaxe da linguagem Python e de seu pacote numerico. Sera

dada uma visao geral das ferramentas escolhidas inicialmente para visua-

lizacao de imagens e graficos, elementos importantes na analise de resultados.

Sera apresentado o PIL1 como ferramenta de leitura e gravacao de varios for-

matos de arquivos de imagem. O ambiente Adesso de desenvolvimento de

software sera introduzido e sera detalhada a primeira contribuicao signifi-

cativa deste trabalho com o suporte feito, para Python, para o processo de

geracao automatica de codigo e documentacao. Serao vistos ainda: a estru-

turacao XML adotada, o processo de transformacao, a geracao de codigo, de

1Python Imaging Library

3.1. PROGRAMACAO EM PYTHON 21

wrapper e setup, alem da geracao de documentacao.

3.1 Programacao em Python

Python e uma linguagem suficientemente generica, capaz de ser aplicada

a uma expressiva quantidade de problemas, superior a de outras linguagens

no mesmo nıvel, como por exemplo, Awk, Perl ou Tcl. E ainda assim, apre-

senta um sintaxe bastante atraente pela elegancia e simplicidade. Estas ca-

racterısticas proporcionam, em geral, reducao de esforco na manutencao de

codigo, desenvolvimento de aplicacoes de forma mais rapida que o de lingua-

gens como C, C++ ou Java. O codigo-fonte resultante normalmente tambem

e menor basicamente por tres motivos: os tipos de dados de elevado nıvel,

em Python, podem traduzir expressoes complexas em comandos bastante

simples; Python e uma linguagem nao-declarativa, ou seja, nao e necessario

definir variaveis ou argumentos antes de utiliza-los e os mesmos podem assu-

mir tipos diferentes conforme o fluxo do programa (tipagem dinamica); um

bloco de comandos, em Python, e marcado simplesmente pela indentacao,

forcando o desenvolvedor a manter um codigo visualmente limpo. Por estes

motivos tambem, um programa Python se adapta facilmente na descricao de

algoritmos por se apresentar, em geral, quase como um pseudo-codigo.

As estruturas de dados implementadas, em Python, dao boa flexibilidade

ao usuario. Em C, estruturas equivalentes de mesmo rigor de otimizacao,

custaria bom tempo de implementacao. Outra caracterıstica importante

e que, alem destas estruturas, ha um grande conjunto nativo de bibliote-

cas implementadas em C (built-in), para Python, que torna o processo de

compilacao/correcao/re-compilacao totalmente descartado (a menos que se

queira estender a linguagem com uma API). Com isto, ha um ganho em pro-

dutividade. A Tabela 3.1 apresenta um quadro resumo com as operacoes mais

comuns sobre alguns destes tipos de objetos built-in. Em Python, alem des-

tas estruturas, funcoes, modulos, metodos, classes, codigo compilado tambem


sao encarados como objetos.

3.1.1 Pacote Numerical

O pacote Numerical [3] e um conjunto de extensoes para Python que ofe-

rece varias funcionalidades para manipulacao de conjuntos de objetos cha-

mados arrays que, por sua vez, podem ter qualquer numero de dimensoes

(multidimensional). A vantagem destas extensoes e permitir que se possa

processar grandes volumes de dados (numeros) de forma tao rapida quanto

ao que e feito, com os mesmos resultados, em linguagens compiladas. Alem

disto, tambem e oferecido suporte simples, com boa documentacao, para

construcao de API’s. A maior parte do codigo do Numerical foi escrita por

Jim Hugunin, enquanto aluno de graduacao do MIT. O trabalho entao pas-

sou a ser mantido por um grupo de pesquisadores do laboratorio LLNL da

Universidade da California. O Numerical apresenta uma comunidade de de-

senvolvimento bastante ativa e vem, atualmente, sofrendo otimizacoes com

o proposito de que o pacote passe a incorporar a distribuicao padrao do

Python.

Para exemplificar algumas funcionalidades do Numerical, volta-se agora

ao exemplo da Secao 2.3, no qual se queria construir uma imagem em forma

de xadrez. A Figura 3.1 mostra o conteudo de um modulo com sete funcoes

(xadrez1, xadrez2, ... xadrez7) que determinam resultados identicos. O

princıcio de funcionamento das diferentes versoes sao: em (1) e implemen-

tada a varredura explıcita com preenchimento de valores pixel a pixel; em (2)

e utilizada a funcao fromfunction do Numeric, na qual, pode-se definir uma

funcao auxiliar que trabalhe com um ındice em particular, representando o

calculo que e repetido para todos os demais ındices conforme a dimensao

dada; em (3) e (4) sao construıdas duas matrizes com malha de ındices na

horizontal e vertical (conforme a Figura 2.6), em (5) e criada uma pequena

matriz 2x2 com elementos 0 e 1 na primeria linha, 1 e 0 na segunda linha,

sendo a mesma replicada em ambas direcoes ate a dimensao dada; em (6)


Operacoes comuns Exemplos de sintaxe

Numeros inteiro normal >>> 1234

inteiro longo >>> 99999999L

ponto flutuante >>> 1.23, 3.14e-10

octal e hexadecimal >>> 0177, 0x9ff

complexo >>> 2+1j, complex(2,1)

Strings string vazia >>> s1=’’

aspas >>> s2="Fulanos’s name"

indexacao e slicing >>> s2[i], s2[i:j]

concatenacao e replicacao >>> s1+s2, 3*s2

formatacao >>> "Nome do %s" % ’Fulano’

aspas tripla >>> bloco="""..."""

Listas lista vazia >>> L1=[]

4 elementos: ındices 0. . . 3 >>> L2=[0,1,2,3]

sub-listas aninhadas >>> [’abc’,[’def’,’ghi’]]

indexacao e slicing >>> L2[i], L2[i:j]

concatenacao e replicacao >>> L1+L2, 3*L2

metodos (inclusao) >>> L2.append(novo_valor)

exclusao >>> del L2[k], L2[i:j]=[]

associacao de sub-lista >>> L2[i:j]=[1,2,3]

lista de inteiros >>> range(4), xrange(0,4)

Dicionarios dicionario vazio >>> d1={}

3 elementos >>> d2={’pera’:2,’uva’:1,’maca’:3}

aninhamento >>> d3={’cesta’:{’uva’:1,’banana’:2}}

indexacao >>> d2[’maca’], d3[’cesta’][’uva’]

metodos >>> d2.has_key(’maca’), d2.keys()

Tuplas tupla vazia >>> ()

1 elemento >>> t1=(0,)

4 elementos >>> t2=(0,1,2,3)

aninhamento >>> t3=(’abc’,(’def’,’ghi’))

indexacao, slicing >>> t1[i], t1[i:j]

concatenacao e replicacao >>> t1+t2, 3*t2

Tabela 3.1: Quadro resumo de algumas estruturas built-in.


"""Varredura explicita""" from Numeric import zeros a = zeros(s) for i in range(s[0]): for j in range(s[1]): a[i,j] = (i+j) % 2 return a

def xadrez1(s):

def xadrez2(s): """Usando ’fromfunction’""" from Numeric import fromfunction def elementos(i,j): return (i+j) % 2 a = fromfunction(elementos, s) return a

def xadrez3(s):

from Numeric import indices (i,j) = indices(s) return (i+j) % 2

"""Usando ’indices’"""

def xadrez_teste(s): """Testes das funcoes com shape s = (height,width)""" from time import time funlist = (xadrez1,xadrez2,xadrez3,xadrez4,xadrez5,xadrez6,xadrez7) print ’Tempos das funcoes para imagem de’, s, ’\n’+50*’−’ for fun in funlist: t1, f, t2 = time(), fun(s), time() print fun.__name__, fun.__doc__, ’\t−>’, ’%.4f’ %(t2−t1), ’segundos’

def xadrez7(s): """Usando ’resize’""" from Numeric import arange, array, resize r = arange(s[1]) % 2 linha = array([r, 1−r]) a = resize(linha, s) return a

def xadrez6(s): """Usando slices """ from Numeric import zeros a = zeros(s) a[ ::2,1::2] = 1 a[1::2, ::2] = 1 return a

def xadrez5(s): """Usando ’iatile’""" from ia636 import iatile from Numeric import array return iatile(array([[0,1],[1,0]]), s)

def xadrez4(s): """Usando ’iameshgrid’""" from ia636 import iameshgrid (i,j) = iameshgrid(range(s[1]), range(s[0])) return (i+j) % 2

1

2

3

4

5

6

7

Figura 3.1: Modulo com sete funcoes diferentes para se gerar uma mesmaimagem em forma de xadrez.


e criada uma matriz de zeros, assim como em (1), porem, desta vez e feito

uso de slices para acessar e preencher todos elementos que devem receber o

valor 1; finalmente, em (7), sao construıdas as duas primeiras linhas da ima-

gem xadrez seguida do redimensionamento que se deseja. Observa-se que sao

feitas importacoes de funcoes do modulo Numeric. Este e mais comumente

usado mas, no Numerical, ha tambem os modulos FFT, LinearAlgebra, MLab,

RandomArray, entre outros. As funcoes iameshgrid e iatile usadas, respec-

tivamente, no xadrez4 e xadrez5 sao provenientes do modulo ia636 (vide

Secao 4.1) que e um dos resultados deste trabalho. Adiantando, iameshgrid

e similar ao Numeric.indices, porem aceita que os valores da malha se-

jam criados a partir de sequencias quaisquer, incluindo numeros fracionarios

por exemplo; e iatile tem a funcao de replicar uma matriz na horizon-

tal e na vertical ate que se atinja uma dada dimensao. Ainda no modulo

da Figura 3.1, tem-se uma funcao encarregada de testar todas as demais,

chamada xadrez teste. Ao importar este modulo no intepretador Python

(em um Athlon XP 1.4GHz), e para uma imagem de 1024x1024, e obtido o

seguinte resultado:

>>> xadrez_teste((1024,1024))

Tempos das funcoes para imagem de (1024, 1024)

--------------------------------------------------

xadrez1 Varredura explicita -> 7.1467 segundos

xadrez2 Usando ’fromfunction’ -> 0.3545 segundos

xadrez3 Usando ’indices’ -> 0.3540 segundos

xadrez4 Usando ’iameshgrid’ -> 0.2373 segundos

xadrez5 Usando ’iatile’ -> 0.0547 segundos

xadrez6 Usando slices -> 0.0543 segundos

xadrez7 Usando ’resize’ -> 0.0236 segundos

Para ilustrar, em C, o tempo medio de varredura explıcita de pixels

(analogo ao xadrez1) foi de 0.0118 segundos e a replicacao de linhas

(analogo ao xadrez7) foi de 0.0034 segundos. Pode-se dizer, porem, que

o uso de linguagens matriciais gera codigo, muitas vezes, mais eficiente ate

mesmo que o de linguagens de mais baixo nıvel (como visto na Tabela 2.1).


Esta afirmacao so e valida considerando um mesmo resultado gerado a partir

de solucoes de programacao em cada ambiente. No caso de operadores matri-

ciais, por exemplo, nao ha informacao explıcita de como as iteracoes ocorrem

internamente e, portanto, nao ha comparacao de implementacoes identicas.

O que pretende-se dizer, com isto, e que sempre e possıvel programar em C

mais eficientemente que em Python. Mas os operadores implementados em

Python geralmente oferecem um grau de otimizacao dificilmente alcalcado em

implementacoes despreocupadas em C. Uma observacao interessante a partir

desta experimentacao em linguagens de nıveis diferentes e que a pratica de

programacao na forma matricial pode induzir a se escrever em C de forma

mais eficiente. No exemplo do xadrez visto, a melhor solucao obtida, para

confirmar esta tese, faz uso de caracterısticas das CPUs modernas que im-

plementam a copia de vetores em hardware (memcpy em C).

3.1.2 Interface Grafica

A exibicao de imagens e possıvel atraves de modulos como wxPython,

PyGTK, PyQt, apenas para citar alguns. Optou-se pelo uso do modulo

Tkinter, uma interface GUI2 padrao do Python, orientada a objetos, para

funcionalidades do pacote Tk [34]. Esta escolha se deu primeiramente por

se tratar de um modulo nativo da linguagem, ou seja, sem necessidade de

instalacao de pacotes extras para este fim, e principalmente por se tratar de

uma interface bastante utilizada em aplicacoes ja desenvolvidas no sistema

Adesso. O porte para Python fica, portanto, facilitado em muitos casos. A

ferramenta implementada em Tkinter para mostrar uma imagem na tela vem

sendo aprimorada pelo aluno de iniciacao cientıfica Guilherme Mazzela [11].

Quanto a exibicao de graficos, existem varias ferramentas que podem ser

localizadas a partir do site oficial do Python. Foi escolhido o Gnuplot3 [35]

por ser bastante poderoso, portavel, distribuıdo sob licenca GNU-GPL, e ser

2Graphical User Interface3http://www.gnuplot.info


>>> import Numeric>>> from ia636 import *>>> f = iaread(’cameraman.pgm’)>>> (g,a) = iasobel(f)>>> iashow(f)>>> iashow(Numeric.log(g+1))>>>>>> h = ialog((200,300), (100,150), 20)>>> iashow(h)>>> iaplot(h[99])

Figura 3.2: Script de teste de exibicao de imagem e grafico.


utilizado em varios sistemas de computacao cientıfica como, por exemplo,

o Octave [8], uma opcao gratuita compatıvel com o MATLAB. A interface

Gnuplot.py4 e escrita em Python puro, sendo simples de ser instalada em

diversas plataformas. A Figura 3.2 mostra um script no ambiente do in-

terpretador e as janelas geradas a partir do uso de funcoes de visualizacao

implementadas (iashow para exibicao de imagens e iaplot para graficos).

Neste exemplo, e feita a exibicao de uma imagem original f , do logaritmo

sobre o resultado da aplicacao de uma filtro de Sobel em f . Depois, ha a

sintentizacao de uma imagem 2-D do Laplaciano da Gaussiana h e, por fim,

a exibicao do grafico resultante da extracao da centesima linha (a central)

de h.

3.1.3 Formatos de Arquivo

O uso dos mais diversos formatos de arquivos de imagens e possıvel

atraves da extensao PIL [18]. Este pacote, de codigo aberto e livremente dis-

tribuido, talvez seja a referencia mais comum entre os softwares, em Python,

que necessitam fazer leitura e escrita de imagens. Ha uma lista discussao

no site oficial da linguagem ([email protected]) justamente para dis-

cutir as questoes referentes ao suporte de imagens em Python e, sobretudo,

as questoes relativas ao pacote PIL. O PIL tambem inclui funcionalidades

basicas de tratamento de imagens, porem alem de sua arquitetura nao ser

facilmente visıvel ao usuario, e preferıvel utilizar funcoes normais de matri-

zes multidimensionais pois, desta forma, o aluno tem uma leitura melhor

do codigo-fonte podendo, com isto, reforcar o entendimento das equacoes

de um curso nesta area. De outra forma, o trabalho consistiria apenas de

um conjunto de funcoes especıficas programadas para resolver problemas de

processamento de imagens. Neste mesmo caminho, quando a ferramenta es-

colhida e o MATLAB, procura-se evitar o uso da toolbox de processamento

de imagens, mas sim os recursos inerentes a imagens de processamneto de

4http://gnuplot-py.sourceforge.net

3.2. O SISTEMA ADESSO 29

Base de DadosXML

Algoritmos..Documentação

Folhas deEstilo

.DocBook

Código CAPI C/ PythonAPI C/MATLABAPI C/TclMakefile

.....

Processadorde Estilos

......

Código MATLABCódigo TclDemonstraçõesTestsuitesSetup

Código Python

. HTML , outros...(1)

(a) Geral.

DocBook

LaTeX

HTML

Estilos deDocumentação

PDF

(2)

Processadorde Estilos

(b) Documentacao.

Figura 3.3: Esquema de transformacao do Sistema Adesso.

matrizes.

3.2 O Sistema Adesso

O Adesso [21, 7] e um projeto conjunto entre a Fundacao CenPRA e

a FEEC-Unicamp que explora o modelo de programacao baseado em com-

ponentes reutilizaveis. Esta abordagem fornece suporte ao desenvolvimento

de componentes e sua integracao a diversas plataformas de programacao

cientıfica. O Adesso configura-se em uma base de dados de algoritmos repre-

sentada em XML [31] e em um conjunto de ferramentas de transformacao

(stylesheets) para a geracao de codigo, documentacao e empacotamento. A

Figura 3.3(a) mostra o esquema de como esta transformacao ocorre. Ha uma

base de dados XML, de entrada, contendo todas as informacoes pertinentes

a caixa de ferramentas tais como algoritmos C, Python e diversos campos de

documentacao. Ha um conjunto de folhas de estilo, cada qual para uma saıda

especıfica, contendo instrucoes para geracao de codigo-fonte C ou Python,

testsuites, arquivos de configuracao e instalacao (setup.py) e DocBook [33].


AdToolbox(name, prefix, title, major, minor, vdate)

Short

Documentation

AdIncludeToolbox(name, rel)

Bibliography

Categories

Category(name, Title, Short, Descr)*

Directories

Directory(dir, name, Title, Short, Descr)*

Releases

Release(name, Title, Short, Descr)*

AdStylesheets

AdDatatypes

AdFunctions

AdLegacyFiles(Exports*, CSourceFile*, CIncludeFile*, PySourceFile*, OtherFile*, DataFile*)

AdLegacyInclude

AdLegacySource

AdExternalFiles

AdDemo(name, exposed, documented, xref, dir, cat, rel, state, lang)*

AdFunction(name, exposed, documented, xref, dir, cat, rel, state, lang)*

AdCFunction(name, exposed, documented, xref, dir, cat, rel, state, lang)*

Figura 3.4: Estrutura XML do Adesso.

Este ultimo formato e estruturado em XML, e facilita a geracao de LATEX,

PDF5, HTML6, entre inumeras outras possibilidades de documentacao, dada

uma folha de estilo especıfica de transformacao. A Figura 3.3(b) ilustra este

esquema de transformacao para documentacao. O processador de estilos do

Adesso se encarrega de ler as duas entradas (base de dados em XML e a folha

de estilo) e gerar a saıda solicitada.

3.2.1 Estruturacao em XML

Os arquivos XML do sistema Adesso formam uma base de dados contendo

algoritmos e suas descricoes, parametros de entrada e saıda e suas descricoes,

exemplos, equacoes, testes, indicacoes de dependencias, entre outros campos.

Estas informacoes sao totalmente armazenadas em texto ASCII, no qual, as

marcacoes definem a estrutura em forma de arvore apresentada na Figura 3.4.

5Portable Document Format6HyperText Markup Language


<Dependencies><Module name="Numeric">cos sin pi</Module></Dependencies>

<Documentation>

<Descr name="Examples"> <Mcode>f = <Self/>([5 10], 6, 0)</Mcode>

<Mcode>f = <Self/>([128 256], 100, pi/4); iashow(f); plot(f(1,:)); showfig(f(1,:));</Mcode> <PYcode>import Numeric f = <Self/>((5,10), 6, 0) print f</PYcode>

iashow(f) (g,d) = iaplot(f[0]) showfig(f[0])</PYcode></Descr>

<Descr name="Description">Generate a cosenosoid image of size s with amplitude 1, period T,

<Par/>

<?xml version="1.0" encoding="ISO−8859−1"?><AdFunction name="iacos" state="alpha" lang="matlab python">

<Seealso>iabwlp iacircle iacomb iagaussian ialog iaramp iarectangle</Seealso><Short>Create a cossenoidal image.</Short>

<Par/> <PYcode>f = <Self/>([256,256], 100, Numeric.pi/4)

phase phi and wave direction of theta. The output image is a double array.</Descr>

<Descr name="Equation"> <Eq>f(x,y) & = & sin( 2\pi (f_x x + f_y y) + \phi) \\ f_x & = & \frac{cos(\theta)}{T} \\ f_y & = & \frac{sin(\theta)}{T}</Eq></Descr></Documentation>

<Return name="f" type="mmIMAGE" output="yes" constraint="IMAGE"/>

<Args>

<Arg name="phi" type="mmDOUBLE" dir="in" optional="no" default="0" hidden="no">

<Descr>phase</Descr></Arg></Args>

<Source lang="matlab"><Code><![CDATA[

cols=s(2); rows=s(1);

[x y] = meshgrid(0:cols−1,0:rows−1); freq = 1/t;

fcols = freq * cos(theta); frows = freq * sin(theta);

f = cos(2*pi* (fcols*x + frows*y) + phi);]]></Code></Source>

(x, y) = iameshgrid(range(cols),range(rows)); freq = 1./t

fcols = freq * cos(theta); frows = freq * sin(theta)

f = cos(2*pi*(fcols*x + frows*y) + phi)]]></Code></Source>

<Source lang="python"><Code><![CDATA[

cols, rows = s[1], s[0]

<ExternalFiles/></Testsuite>

<Platforms>windows linux sunos</Platforms>

<ExternalFiles/></AdFunction>

<Descr>spatial direction of the wave, in radians. 0 is a wave on the horizontal direction.</Descr></Arg>

<Arg name="t" type="mmIMAGE" dir="in" constraint="IMAGE" optional="no" default="" hidden="no">

<Descr>period: in pixels.</Descr></Arg>

<Arg name="theta" type="mmDOUBLE" dir="in" constraint="DOUBLE" optional="no" default="" hidden="no">

<Testsuite><Code lang="matlab"><![CDATA[...]]></Code><Code lang="python"><![CDATA[...]]></Code>

<Descr>size: [rows cols].</Descr></Arg>

<Arg name="s" type="mmIMAGE" dir="in" constraint="IMAGE" optional="no" default="" hidden="no">

Figura 3.5: Exemplo de estrutura XML para descricao de uma funcao.


Entre parenteses aparecem os atributos do elemento em questao na arvore

XML e, algumas vezes, para simplificar, seus filhos (escritos em maiusculo).

Os elementos notados por asterisco (*) indicam que pode haver mais filhos

do mesmo tipo na arvore. A distincao, neste caso, e dada pelos atributos

e conteudo de tais elementos. A Figura 3.5 mostra um exemplo, sem o

conteudo dos testsuites, de um codigo XML para a descricao de uma funcao

(AdFunction). Observa-se, exceto os trechos onde ha codigo-fonte, que as

informacoes podem ser compartilhadas para documentacao de mais de uma

linguagem, no caso, Python e MATLAB. A implementacao de folhas de estilo

para interpretar esta nova estrutura XML com suporte a multiplas linguagens

foi uma contribuicao deste trabalho.

3.2.2 Processo de Transformacao

O processador de estilos do Adesso e baseado em um processo de subs-

tituicoes de texto inspirado na linguagem XSL7 [32]. A implementacao e

feita com uso do pacote tDOM [14] para Tcl (linguagem de programacao do

Adesso). O tDOM possibilita que se trabalhe com um parser XML e arvore

DOM8 [30], alem da linguagem de query XPath [29]. Com este conjunto,

passa-se a ter a representacao de um documento XML em memoria, garan-

tindo, desta forma, o acesso rapido as marcacoes e atributos que podem ser

localizados assim como se localiza um arquivo em um sistema de diretorios

comum, tambem estruturado em forma de arvore. O exemplo de folha de

estilo apresentado no Apendice B ilustra a aplicacao de alguns dos comandos

do Adesso descritos a seguir:

sty:apply - implementa a varredura de um conjunto de elementos da arvore

especificados por uma expressao XPath, transferindo o fluxo de proces-

samento de uma folha de estilo a um template em particular;

7Extensible Style Language8Document Object Model


sty:foreach - identico ao sty:apply, exceto por nao fazer busca por

template;

sty:value - retorna o string de um texto, atributo ou lista de atributos

conforme a expressao XPath fornecida;

sty:if - avalia se uma expressao XPath resulta verdadeiro, procedendo ou

nao a substituicao solicitada;

sty:iif - similar ao sty:if, mas avalia uma expressao Tcl em vez de uma

expressao XPath;

sty:par - realiza tratamento de parametros ou operacoes aritmeticas sim-

ples;

sty:call - retorna o conteudo de uma macro definida;

sty:tag - gera marcacoes XML/HTML. Exemplo: [sty:tag body] produz

<body>;

sty:save - grava em arquivo todas as substituicoes geradas;

sty:copy - copia arquivos quaisquer;

sty:logIt - exibe mensagens para comentar o fluxo de execucao.

3.2.3 Geracao de Codigo

Atraves do conteudo registrado em XML, representado nas Figuras 3.4

e 3.5, e possıvel gerar automaticamente codigo-fonte em uma dada lingua-

gem. Folhas de estilos para Python e MATLAB foram implementadas com

esta finalidade. Para exemplificar esta transformacao, restringe-se a solucao

adotada ao Python. As demais linguagens de scripting seguem modelo se-

melhante de formacao de codigo.


1

3

9

4

2

8

7

56

# =====================================================================## iacos## =====================================================================def iacos(s, t, theta, phi=0): """ − Purpose Create a cossenoidal image. − Synopsis f = iacos(s, t, theta, phi=0) − Input s: size: [rows cols]. t: period: in pixels. theta: spatial direction of the wave, in radians. 0 is a wave on the horizontal direction. phi: phase − Output f: − Description Generate a cosenosoid image of size s with amplitude 1, period T, phase phi and wave direction of theta. The output image is a double array. − Examples # # example 1 # import Numeric f = iacos((5,10), 6, 0) print f # # example 2 # f = iacos([256,256], 100, Numeric.pi/4) iashow(f) (g,d) = iaplot(f[0]) """ from Numeric import cos, sin, pi cols, rows = s[1], s[0] (x, y) = iameshgrid(range(cols),range(rows)) freq = 1./t fcols = freq * cos(theta) frows = freq * sin(theta) return f

10

(iii) Documentação

(ii) Protótipo

(i) Comentários

(iv) Corpo

(v) Retorno

Figura 3.6: Exemplo de codigo-fonte Python gerado automaticamente.

O Apendice B mostra o corpo principal (sem a declaracao das diversas

macros usadas) da folha de estilo para codificacao em Python. A caixa de

ferramentas, a ser gerada, foi definida como sendo formada por tres grandes

modulos: de funcoes em si (ia636); de demonstracoes ou licoes (ia636demo);

de conjuntos de testes chamados testsuites (ia636test).

Geracao de Funcoes

Uma funcao Python pode ser dividida em 5 partes: (i) comentarios de

programacao atraves do sustenido (#); (ii) prototipo ou cabecalho definido

pela palavra reservada def; (iii) documentacao, entre aspas tripla ("""),


que podera ser consultada no interpretador com uso do comando help do

Python; (iv) corpo do codigo com todas as instrucoes da linguagem para im-

plementacao do procedimento; e (v) descricao dos objetos a serem retornados

definidos pela palavra reservada return. A Figura 3.6 mostra um codigo de

funcao gerado automaticamente, indicando esta estrutura. Os campos nu-

merados de 1 a 10 foram extraıdos dos documentos XML de entrada: (1)

atributo name da marcacao XML AdFunction; (2) listagem de todos argu-

mentos, dados pelo atributo name da marcacao Arg, separados por vırgula,

com a associacao de seus respectivos valores padrao, dados pelos atributos

optional e default ; (3) descricao curta da finalidade da funcao, dada pelo

texto da marcacao Short (filho de AdFunction); (4) copia da indicacao (2),

com o acrescimo da atribuicao as variaveis de retorno, dada pelo atributo

name da marcacao Return; (5) listagem novamente dos nomes dos argumen-

tos seguidos de suas descricoes, dadas pelo texto da marcacao Descr (filho

de Arg); (6) de novo, a listagem das variaveis de retorno, agora seguidas

por suas descricoes; (7) descricao mais detalhada dos objetivos e funciona-

mento da funcao, dada pelo texto da marcacao Descr, cujo atributo name

e “Description”; (8) textos dos scripts contidos nas marcacoes PYcode para

exemplificar a forma de uso da funcao; (9) codigo propriamente dito prove-

niente da marcacao Source, cujo atributo lang e definido como “python”;

(10) nome das variaveis de retorno separadas por vırgula, caso haja mais de

uma.

Este processo de construcao se repete para todas as funcoes da base de

dados XML. Todo o codigo gerado desta forma constitui o modulo ia636.

Geracao de Demonstracoes

Demonstracoes sao funcoes diferenciadas, sem parametro de entrada e

com retorno nulo (None), estruturadas pela marcacao AdDemo. Como filhos

desta, ha uma sequencia de marcacoes Slide, cada qual, responsavel por

registrar um trecho de uma explicacao sobre um algoritmo ou um trecho de


<?xml version="1.0" encoding="ISO−8859−1"?><AdDemo name="iadftmatrixexamples" state="alpha" lang="matlab python">

<Dependencies/> <Seealso/> <Short>Demonstrate the kernel matrix for the DFT Transform.</Short> <Documentation/>

<Source> <Slide title="Kernel images generated"> <Descr>Imaginary and real parts of the DFT kernel.</Descr> <Code lang="matlab">A = iadftmatrix(128); Aimag = imag(A); Areal = real(A); iashow(Aimag); iashow(Areal);</Code> <Code lang="python">A = iadftmatrix(128) Aimag, Areal = A.imag, A.real iashow(Aimag) iashow(Areal)</Code></Slide>

<Slide title="Three first lines"> <Descr>Three first lines from imaginary and real parts of the kernel matrix. Observe the increasing frequencies of the senoidals (imaginary part) and cossenoidals (real part).</Descr> <Code lang="matlab">x = 0:127; plot(x,Aimag(1,:), x,Aimag(2,:), x,Aimag(3,:)); showfig(x,Aimag(1,:), x,Aimag(2,:), x,Aimag(3,:)); plot(x,Areal(1,:), x,Areal(2,:), x,Areal(3,:)); showfig(x,Areal(1,:), x,Areal(2,:), x,Areal(3,:));</Code> <Code lang="python">

g1.plot(i1,i2,i3) showfig(i1,i2,i3) g2,r1 = iaplot(Areal[0,:]); g2,r2 = iaplot(Areal[1,:]); g2,r3 = iaplot(Areal[2,:])

g1,i1 = iaplot(Aimag[0,:]); g1,i2 = iaplot(Aimag[1,:]); g1,i3 = iaplot(Aimag[2,:])

g2.plot(r1,r2,r3) showfig(r1,r2,r3)</Code></Slide></Source>

<Platforms>windows linux sunos</Platforms> <ExternalFiles/></AdDemo>

Figura 3.7: Exemplo de estrutura XML para descricao de uma demonstracao.

uma licao sobre algum topico de processamento de imagens. A Figura 3.7

ilustra um exemplo desta organizacao.

Todas as demonstracoes constituem o modulo ia636demo. As funcoes

geradas ilustram varias saıdas, numericas ou graficas (pelo print, iashow

ou iaplot), passo a passo. A Figura 3.8 mostra o codigo gerado para a

estrutura XML exemplificada na Figura 3.7. As indicacoes feitas sao: (1)

atributo name de AdDemo; (2) texto da marcacao Short (filho de AdDemo);

(3) texto da marcacao Descr (filho de Slide); (4) texto da marcacao Code,

cujo atributo lang e “python”, que contem o script de execucao. Observe

que em (4), o script e visualizado na tela pelo comando print e depois

executado. Neste exemplo, o slide 1 exibe duas imagens (Aimag e Areal). Ao

seu termino, e pedido para que se pressione “return” para continuar. Inicia-se

o proximo slide que, neste caso, exibe dois graficos. Na Figura 3.9, pode-se

ver as saıdas desta funcao quando a mesma e chamada no interpretador.


1

2

3

4

3

4

# =========================================================================## iadftmatrixexamples## =========================================================================def iadftmatrixexamples(): print print ’’’Demonstrate the kernel matrix for the DFT Transform.’’’ print print print ’=========================================================================’ print ’’’ Imaginary and real parts of the DFT kernel. ’’’ print ’=========================================================================’ print ’’’ A = iadftmatrix(128) Aimag, Areal = A.imag, A.real iashow(Aimag) iashow(Areal)’’’ A = iadftmatrix(128) Aimag, Areal = A.imag, A.real iashow(Aimag) iashow(Areal) print raw_input(4*’ ’+’Please press return to continue...’) print print print ’=========================================================================’ print ’’’ Three first lines from imaginary and real parts of the kernel matrix. Observe the increasing frequencies of the senoidals (imaginary part) and cossenoidals (real part). ’’’ print ’=========================================================================’ print ’’’

g2,r1 = iaplot(Areal[0,:]); g2,r2 = iaplot(Areal[1,:]); g2,r3 = iaplot(Areal[2,:]) g2.plot(r1,r2,r3)’’’ g1,i1 = iaplot(Aimag[0,:]); g1,i2 = iaplot(Aimag[1,:]); g1,i3 = iaplot(Areal[2,:]) g1.plot(i1,i2,i3) g2,r1 = iaplot(Areal[0,:]); g2,r2 = iaplot(Areal[1,:]); g2,r3 = iaplot(Areal[2,:]) g2.plot(r1,r2,r3)

print raw_input(4*’ ’+’Please press return to continue...’) print print return

g1.plot(i1,i2,i3) g1,i1 = iaplot(Aimag[0,:]); g1,i2 = iaplot(Aimag[1,:]); g1,i3 = iaplot(Aimag[2,:])

Slide 2

Slide 1

Figura 3.8: Codigo-fonte de demonstracao gerado automaticamente.


>>> iadftmatrixexamples()

=========================================================================

Imaginary and real parts of the DFT kernel. =========================================================================

A = iadftmatrix(128) Aimag, Areal = A.imag, A.real iashow(Aimag) iashow(Areal)(128, 128) Min= −0.0883883476483 Max= 0.0883883476483 Mean=−0.000 Std=0.06(128, 128) Min= −0.0883883476483 Max= 0.0883883476483 Mean=0.001 Std=0.06

Please press return to continue...

=========================================================================

Three first lines from imaginary and real parts of the kernel matrix. Observe the increasing frequencies of the senoidals (imaginary part) and cossenoidals (real part). =========================================================================

g1,i1 = iaplot(Aimag[0,:]); g1,i2 = iaplot(Aimag[1,:]); g1,i3 = iaplot(Aimag[2,:]) g1.plot(i1,i2,i3) g2,r1 = iaplot(Areal[0,:]); g2,r2 = iaplot(Areal[1,:]); g2,r3 = iaplot(Areal[2,:]) g2.plot(r1,r2,r3)

Please press return to continue...

>>>

Demonstrate the kernel matrix for the DFT Transform.

Figura 3.9: Exemplo de saıda gerada quando na execucao de uma demons-tracao.


Geracao de Testsuites

Os testsuites sao exemplos que comparam as saıdas das funcoes com va-

lores considerados corretos, gerado na maioria das vezes, analiticamente. A

Figura 3.10 mostra, a esquerda, um trecho XML que organiza o tratamento

dos testsuites e, a direita, um trecho do resultado da transformacao, o modulo

ia636test, feita pelo processador de estilos. Os campos numerados sao: (1)

e (2), respectivamente, os atributos name e title de AdToolbox; (3) atributo

name de AdFunction, seguido da descricao curta da funcao em Short (filho

de AdFunction); (4) texto de Code (filho de Testsuite), cujo atributo lang

e “python”.

Ao importar o modulo ia636test, obtem-se como resultado o teste de to-

das funcoes implementadas da caixa de ferramentas. A seguir, sao mostradas

as primeiras linhas desta saıda:

>>> import ia636test

Testsuite ia636 -- Toolbox ia636

=====================================================================

iabwlp - Low-Pass Butterworth frequency filter.

=====================================================================

testing iabwlp

1

=====================================================================

iacircle - Create a binary circle image.

=====================================================================

testing iacircle

1

1

1

=====================================================================

iacos - Create a cossenoidal image.

=====================================================================

testing iacos

1

...


import Numeric

from ia636 import *

print

print ’’’Testsuite ia636 −− Toolbox ia636’’’

print

print ’=====================================================================’

print ’’’iabwlp − Low−Pass Butterworth frequency filter.’’’

print ’=====================================================================’

print ’testing iabwlp’

print ‘Numeric.floor(0.5 + 1E4*iabwlp([5,8],2,3)) / 1E4‘ == ‘Numeric.array(

[[ 0.9983, 0.9955, 0.9722, 0.8649, 0.6073, 0.8649, 0.9722, 0.9955],

[ 0.9021, 0.8744, 0.774 , 0.5813, 0.3537, 0.5813, 0.774 , 0.8744],

[ 0.9021, 0.8744, 0.774 , 0.5813, 0.3537, 0.5813, 0.774 , 0.8744],

[ 0.9983, 0.9955, 0.9722, 0.8649, 0.6073, 0.8649, 0.9722, 0.9955],

[ 1. , 0.9999, 0.9936, 0.9313, 0.7071, 0.9313, 0.9936, 0.9999]])‘

print

print ’=====================================================================’

print ’’’iacircle − Create a binary circle image.’’’

print ’=====================================================================’

print ’testing iacircle’

print ‘iacircle([5,7],2,[3,4])‘ == ‘Numeric.array(

[[0, 0, 0, 0, 0, 0, 0],

[0, 0, 0, 0, 1, 0, 0],

[0, 0, 0, 1, 1, 1, 0],

[0, 0, 1, 1, 1, 1, 1],

[0, 0, 0, 1, 1, 1, 0]])‘


[[0, 0, 0, 0, 0, 0, 0],

[0, 0, 0, 0, 0, 0, 0],

[0, 1, 0, 0, 0, 0, 0],

[1, 1, 1, 0, 0, 0, 0],

[1, 1, 1, 1, 0, 0, 0]])‘


[[1, 1, 1, 1, 1, 1, 1],

[1, 1, 1, 1, 1, 1, 1],

[1, 1, 1, 1, 1, 1, 1],

[1, 1, 1, 1, 1, 1, 1],

[0, 1, 1, 1, 1, 1, 1]])‘

print

print ’=====================================================================’

print ’’’iacos − Create a cossenoidal image.’’’

print ’=====================================================================’

print ’testing iacos’

print ‘Numeric.floor(0.5 + 127*(iacos([7,10], 3, Numeric.pi/4, 0)+1))‘ == ‘Numeric.array(

[[ 254., 138., 2., 93., 246., 182., 18., 52., 223., 219.],

[ 138., 2., 93., 246., 182., 18., 52., 223., 219., 48.],

[ 2., 93., 246., 182., 18., 52., 223., 219., 48., 21.],

[ 93., 246., 182., 18., 52., 223., 219., 48., 21., 187.],

[ 246., 182., 18., 52., 223., 219., 48., 21., 187., 244.],

[ 182., 18., 52., 223., 219., 48., 21., 187., 244., 88.],

[ 18., 52., 223., 219., 48., 21., 187., 244., 88., 3.]])‘

12

3

3

3

4

4

4

<Testsuite>

<Code lang="python"><![CDATA[

print ’testing iacos’

print ‘Numeric.floor(0.5 + 127*(iacos([7,10], 3, Numeric.pi/4, 0)+1))‘ == ‘Numeric.array(

[[ 254., 138., 2., 93., 246., 182., 18., 52., 223., 219.],

[ 138., 2., 93., 246., 182., 18., 52., 223., 219., 48.],

[ 2., 93., 246., 182., 18., 52., 223., 219., 48., 21.],

[ 93., 246., 182., 18., 52., 223., 219., 48., 21., 187.],

[ 246., 182., 18., 52., 223., 219., 48., 21., 187., 244.],

[ 182., 18., 52., 223., 219., 48., 21., 187., 244., 88.],

[ 18., 52., 223., 219., 48., 21., 187., 244., 88., 3.]])‘

]]></Code>

<ExternalFiles/></Testsuite>

Testsuit gerado automaticamente

...

XML

Figura 3.10: Exemplo de testsuite gerado automaticamente.


#include "Python.h"#include "Numeric/arrayobject.h"

DLLEXPORT tipo * ia__funcao1(tipo1 * A, tipo2 * B);

static char docstring_modulo_ia_funcao1_wrapper[] = "Documentacao aqui...";static PyObject *modulo_ia_funcao1_wrapper(PyObject *self, PyObject *args) { PyObject *pyout; if (!PyArg_ParseTuple(args, IN_FORMAT1 "|" IN_FORMAT2 ":iafuncao1", IN_CONV1(a), IN_CONV2(b)) return NULL;

y = (TIPO) ia_funcao1( (tipo1 *)a, (tipo2 *)b, ... ); if (!y) return NULL;

pyout = Py_BuildValue(OUT_FORMAT, OUT_CONV(y)); if (!pyout) return NULL; return pyout;}

static PyMethodDef modulo_methods[] = { {"iafuncao1", modulo_ia_funcao1_wrapper, METH_VARARGS, docstring_modulo_ia_funcao1_wrapper}, {"iafuncao2", modulo_ia_funcao2_wrapper, METH_VARARGS, docstring_modulo_ia_funcao2_wrapper}, {"iafuncaoN", modulo_ia_funcaoN_wrapper, METH_VARARGS, docstring_modulo_ia_funcaoN_wrapper}, {NULL, NULL} /* sentinela */};

void init_modulo(void) { PyObject *module, *dict; module = Py_InitModule("modulo", modulo_methods); import_array() dict = PyModule_GetDict(module); TbxErrorObject = PyErr_NewException("_modulo.TbxError", NULL, NULL); PyDict_SetItemString(dict, "TbxError", TbxErrorObject);}

Headers

MóduloIniciação do

Wrapper

ProtótiposDeclaração de

Métodos doMódulo

Figura 3.11: Modelo de construcao de um modulo built-in.

Com esta funcionalidade em maos, espera-se cobrir o maximo de casos

de erro de implementacoes e detectar rapidamente qualquer alteracao de

resultado quando ha atualizacao da caixa de ferramentas.

3.2.4 Geracao de Wrapper

Para que uma funcao C/C++ possa ser utilizada no ambiente Python

e preciso seguir algumas regras de construcao de modulos built-in. A do-

cumentacao do Python e do Numeric para implementacao de uma API9 e

bastante detalhada e oferece varios exemplos. Basicamente e preciso des-

9Application Programmer’s Interface


crever um envoltorio, conhecido como wrapper , na chamada das funcoes

C/C++. Alem disto, devem ser especificados os arquivos de declaracao prin-

cipais (Python.h e Numeric/arrayobject.h), ser declarados os prototipos,

os metodos e, por fim, a caixa de ferramentas deve ser iniciada. A Figura 3.11

exemplifica a construcao de um modulo chamado “modulo” e descreve a cons-

trucao de um wrapper para uma funcao “funcao1”. Em Python, o envoltorio

pode ser implementado com as funcoes PyArg ParseTuple e Py BuildValue.

A primeira se encarrega de transformar os argumentos do tipo PyObject

fornecidos, quando na chamada da funcao pelo interpretador, para o tipos

definidos, em C, da funcao, alem de verificar se o numero de argumentos

de entrada esta correto, considerando tambem os parametros opcionais. A

segunda faz exatamente o contrario, pegando a saıda da funcao para trans-

forma-la em um objeto Python, habil a ser utilizado no interpretador.

Este processo e construıdo seguindo uma sintaxe criteriosa e bem defi-

nida. Isto proporciona que tanto o wrapper como todo o modulo built-in

possa ser gerado automaticamente pelo Adesso. Em XML, as funcoes C sao

definidas pela marcacao AdCFunction. Exceto pela inexistencia do atributo

“lang”, esta estrutura e a mesma que foi vista para codigo Python puro

(AdFunction). No entanto, aqui e essencial que se registre informacoes de

configuracao, de descricao de dependencias, de localizacao de bibliotecas,

de definicao de constantes e macros, para que haja sucesso na compilacao.

Um aspecto importante desta automacao e o mapeamento de tipos de dados

(typemaps). Typemaps sao trechos de codigo C a serem incluıdos no wrap-

per em suas diversas secoes: (i) declaracao de variaveis para cada marcacao

XML Arg e Return; (ii) conversao de tipos para cada Arg e verificacao do

numero de argumentos (PyArg ParseTuple); (iii) chamada da funcao base;

(iv) conversao de tipos para a saıda (Py BuildValue). A Figura 3.12 ilustra

uma parte da folha de estilo responsavel pelo mapeamento do tipo inteiro.

Observe as transformacoes indicadas pelas setas que vao do typemap para

o codigo wrapper gerado. Aqui optou-se por usar a funcao PyInt FromLong


stylesheet python.wrapper_adInteger:

typemap adInteger:

map in.decl: int [att name] = 0;

map in.default: [att name] = [att default];

map in.convert: i

map in.funcsvars: &[att name]

map ignore.decl: int [att name] = 0;

map ignore.default: [att name] = [att default];

map ret.decl: int [att name] = 0;

map ret.output: return PyInt_FromLong([att name]);

DLLEXPORT int ia_funcao2(int a, int b) { int y; y = a + b; return y;}

static PyObject *modulo_ia_funcao2_wrapper(PyObject *self, PyObject *args) { int a, b; int y; if (!PyArg_ParseTuple(args, "ii:ia_funcao2", &a, &b)) return NULL; y = ia_funcao2(a, b); return PyInt_FromLong(y);}

Typemap

Wrapper

Função

(ii)

(i)

(iii)(iv)

Figura 3.12: Exemplo de typemap para o wrapper de uma funcao de somade dois inteiros.

especıfica para inteiros ou inteiros longos, mas tambem poderia ser utilizado

Py BuildValue. Ainda e mostrada a funcao base no canto inferior direito

(ia funcao2) da figura.

As conversoes (ii) e (iv) sao feitas diretamente quando se trata de ti-

pos pre-definidos (string, integer, ponteiro para integer, float, ponteiro

para float, entre outros), porem, podemos tratar vetores, imagens ou qual-

quer outra estrutura. Nestes casos, felizmente, e possıvel fazer chamadas as

funcoes de conversao. Foram implementados os seguintes mapeamentos:

• Transformacao de um tipo objeto Python em um vetor de inteiros, e

vice-versa:

int adpython2intvector(PyObject *arg, int **vector)

PyObject *adintvector2python(int *vector)

• Transformacao de um tipo objeto Python em um vetor de reais (dou-

ble), e vice-versa:

int adpython2dblvector(PyObject *arg, double **vector)

PyObject *addblvector2python(double *vector))


typedef struct { PyObject_HEAD char *data; int nd; int *dimensions, *strides; PyObject *base; PyArray_Descr *descr; int flags;} PyArrayObject;

typedef struct { int row_size; int col_size; int num_data_bands; int data_storage_type; int binary_flag; char *imagedata; int domain_type; int n_domain; int *location;} adimage;

Figura 3.13: Estruturas PyArrayObject e adimage.

• Transformacao de um tipo objeto Python em um tipo opaco, e vice-

versa:

int adpython2pointer(PyObject *arg, void **ptr))

PyObject *adpointer2python(void *ptr))

O tipo opaco e o mapeamento default feito pelo gerador de codigo caso

o tipo tratado nao esteja previamento definido no Adesso.

• Transformacao de um tipo objeto Python (PyArrayObject) em um tipo

imagem (adimage), e vice-versa:

int adpython2adimage(PyObject *arg, adimage **img)

PyObject *adadimage2python(adimage *img))

A Figura 3.13 mostra as estruturas de PyArrayObject e adimage. E

preciso mapear os campos destes dois tipos entre si.

Finalizados estes ajustes, e a vez da folha de estilo agir para se ge-

rar codigo-fonte de API Python/C. Optou-se por incluir todas as funcoes

C e respectivos wrappers em um unico arquivo, facilitando desta forma,

o proximo passo que e o de compilacao. A folha de estilo implementada

instrui a geracao do modulo buit-in incluindo, na ordem, os seguintes tre-

chos de codigo: (1) headers do Python e Numeric; (2) chamadas a funcoes

que promovem alocacao de memoria com suporte a depuracao; (3) codigo

das funcoes de mapeamento de tipos; (4) codigo principal das bibliotecas


da caixa de ferramentas; (5) wrappers para as funcoes em (4); (6) especi-

ficacao de todos os wrappers na variavel de metodos do modulo (do tipo

PyMethodDef); (7) especificacao da funcao de iniciacao do modulo (void

init nome do modulo(void)).

Este processo sistematico automatizado fortalece a consistencia da sin-

taxe, aumenta a imunidade a erros comuns da programacao manual, alem de

possibitar que uma biblioteca, em C, possa se portada em Python com um

mınimo de esforco. O trabalho para portar uma biblioteca existente consiste

agora basicamente em se descrever os prototipos das funcoes (argumentos de

entrada e saıda) e incluir (ou referenciar) o corpo de cada codigo na base de

dados XML. Nao exige, portanto, ser feito por um programador.

3.2.5 Geracao de Setup

Uma vez que o codigo Python puro e o codigo API Python/C foram

gerados, a intencao agora e empacota-los para que se tenha um produto

final, de tal modo que seja facilmente instalado em qualquer plataforma. Nas

versoes mais recentes do Python, ha suporte para empacotamentos deste tipo

atraves do modulo distutils10 (em versoes mais antigas, este modulo pode

ser incorporado). Os pacotes Python comumente trazem em sua distribuicao

um script chamado setup.py. Nele, sao utilizados metodos do distutils

que, a partir basicamente de referencias a localizacoes dos arquivos Python e

bibliotecas C/C++ (caso haja) da caixa de ferramentas gerada, determinam:

(i) a criacao de codigo intermediario (bytecode) Python, verificando, neste

tempo, se ha algum erro de sintaxe; (ii) a compilacao das API’s ligando

a bibliotecas necessarias do Python automaticamente. Caso nao se tenha

qualquer implementacao em C, o passo (ii) e desconsiderado. Em um console

padrao do sistema operacional, usa-se comumente o setup.py de tres formas:

1. python setup.py build - para construcao dos passos (i) e (ii), cita-

10Python Distribution Utilities


from distutils.core import setup, Extension

my_headers = [’modulo.h’]my_ext_modules = Extension( ’_module’, define_macros = [(’EXEMPLO’, None)], include_dirs = incdir1 + incdir2 + incdirN, library_dirs = libdir1 + libdir2 + libdirN, libraries = [’lib1’, ’lib2’, ’libN’], sources = [’module_wrapper.c’] )my_py_modules = [’modulo’, ’modulodemo’, ’modulotest’]my_data_files = [’data/img1.tif’, ’data/img2.jpg’, ’data/imgN.ppm’]

setup ( name = "modulo", version = "1.0", description = "Descricao aqui...", author = "Autor aqui...", py_modules = my_py_modules, ext_modules = my_ext_modules, headers = my_headers, data_files = my_data_files )

Figura 3.14: Modelo de construcao do setup.py.

dos anteriormente, em diretorio temporario, alem da copia de todos

arquivos de dados (como imagens) e modulos auxiliares.

2. python setup.py install - para execucao do item 1, caso ainda nao

tenha sido feito, e instalacao do pacote no ambiente Python instalado.

3. python setup.py bdist - para criacao de distribuicao binaria, na pla-

taforma em questao, a fim de deixar o pacote pronto para ser distribuıdo

e posteriormente instalado.

A Figura 3.14 mostra um modelo de construcao do script setup.py. Uma

folha de estilo foi implementada com o intuito de se gerar este arquivo auto-

maticamente. Os parametros de entrada de Extension e setup sao especifi-

cados extraindo-se as informacoes registradas em XML.

3.2.6 Geracao de Documentacao

A geracao de documentacao consiste em se descrever todos os componen-

tes do pacote computacional. Alguns requisitos sao considerados importantes

neste processo: (i) descricao das funcoes em si, citando sua finalidade, sin-

taxe e parametros de entrada e saıda; (ii) determinacao de exemplos e as


saıdas que devem ser produzidas quando os mesmos sao interpretados pela

linguagem em uso; (iii) estabelecimento de formulas, sempre que possıvel,

pois tornam a descricao da implementacao mais precisa - saber qual e o

comportamento do algoritmo implementado e um ponto crıtico de software

cientıfico (por exemplo: e muito vago dizer que se trata de uma melhoria de

contraste sem uma equacao); (iv) listagem de seu algoritmo ou codigo-fonte,

e funcoes associadas.

Uma folha de estilo para documentacao foi implementada considerando-se

inicialmente que os arquivos XML de entrada passem pelo gerador de estilos

e sejam diretamente transformados em documentos HTML (caminho para se

obter HTML(1) da Figura 3.3). A novidade desta folha de estilo, em relacao

a de geracao de codigo-fonte, e a necessidade de se gerar ilustracoes didaticas

com o objetivo de facilitar a explicacao do funcionamento do software produ-

zido. Por exemplo, quando ha a marcacao de exemplo na descricao da funcao

(PYcode para Python, ou Mcode para MATLAB) o Adesso invoca o interpre-

tador Python que executa o script definido nesta marcacao XML, gerando

as saıdas correspondentes aproveitadas no conteudo da documentacao. Ha

tambem a marcacao de equacoes (Eq) onde e a vez do interpretador LATEX

ser invocado, gerando uma figura de formulas. Sao basicamente quatro tipos

de saıdas: (1) em forma de texto simples ou numericas; (2) imagens; (3)

graficos; (4) equacoes. A Figura 3.15 mostra uma pagina HTML produzida

automaticamente e um esquema das transformacoes para estas quatro saıdas.

Para agilizar a chamada ao interpretador, foi utilizada uma interface com

o Python chamada Tclpython [10]. Desta forma, e possıvel usar todo o am-

biente Python instalado em linhas de comando Tcl que e a linguagem do

Adesso. Pode-se executar entao os scripts , em PYcode, e mapear as saıdas

diretamente em variaveis Tcl. Assim, quando na passagem por um comando

print, no script propriamente dito ou dentro das funcoes chamadas, e regis-

trada a saıda texto a partir do re-direcionamente da saıda padrao no Python

(sys.stdout) para uma variavel. Ja na passagem por um iashow e dado um


Inte

rpre

tado

r L

aTeX

Inte

rpre

tado

r Py

thon

Pro

cess

ador

de

Est

ilos

<PYcode>f = <Self/>([256,256], 100, Numeric.pi/4)

iashow(f)

...

print f</PYcode>

<Par/>

</Descr>

showfig(f[0])</PYcode>

(g,d) = iaplot(f[0])

<Descr name="Examples">

f = <Self/>((5,10), 6, 0)

<PYcode>import Numeric

<Descr name="Equation">

<Eq>f(x,y) & = & sin( 2\pi (f_x x + f_y y) + \phi) \\

f_x & = & \frac{cos(\theta)}{T} \\

f_y & = & \frac{sin(\theta)}{T}</Eq>

</Descr>

1

2

3

4

Figura 3.15: Documentacao HTML gerada automaticamente.


tratamento diferenciado no Tcl. Neste caso, o interpretador Python aberto

passa a gravar, em arquivo (usando o proprio iawrite da caixa de ferra-

mentas) a imagem processada em memoria. Algo similar acontece quando

se detecta um iaplot (mais especificamente, um showfig para que se reco-

nheca as saıdas do iaplot localizado imediatamente antes). A folha de estilo

agora utiliza as funcionalidades do gnuplot para gravar as figuras em formato

PS11. Feito isto, o Tcl passa a chamar o software Ghostscript para conversao

do PS criado em qualquer outro formato reconhecıvel por um navegador de

Internet.

Observe que e necessario manter apenas informacoes textuais para gerar

uma documentacao ilustrada. Evidentemente que tambem e mantido um

conjunto basico de imagens fotograficas mas todas as figuras, referenciadas

na documentacao, sao criadas durante a sua geracao. A importancia da

geracao das figuras desta forma e manter consistencia entre a documentacao

e a ultima versao das implementacoes.

Em relacao as demonstracoes (AdDemo), assim como foi gerado o codigo

ia636demo, a folha de estilo de documentacao HTML tambem se encarrega de

montar paginas ilustrativas contendo os slides para cada uma destas funcoes

especiais.

DocBook

DocBook e um forma aprimorada de automatizacao da documentacao,

mais generica que a mostrada anteriormente onde, em vez de se gerar direta-

mente um formato especıfico (como HTML(1) da Figura 3.3(a)), produzem-se

documentos XML intermediarios com marcacoes padronizadas [33, 21]. Ima-

gens, graficos e equacoes sao gerados em um primeiro momento e suas loca-

lizacoes devidamente referenciadas nos arquivos XML/DocBook. A grande

vantagem desta abordagem fica evidente quando se deseja o produto final

(HTML(2), PDF, LATEX, ou outro formato, conforme a Figura 3.3(b)). Agora

11PostScript


basta ter uma unica folha de estilo de interpretacao do DocBook, dado um

produto final em particular, para todas as linguagens. A consistencia citada

anteriormente assume um sentido ainda mais amplo, pois agora ha solidez

entre as documentacoes de uma mesma caixa de ferramentas para diferentes

linguagens.

Capıtulo 4

Resultados

Neste capıtulo, serao exibidas as funcoes e licoes da caixa de ferramen-

tas implementadas, sera apresentado um sistema criado para correcao au-

tomatica de programas Python de alunos via Internet, sera mostrado o re-

sultado de uma avaliacao de alunos feita ao ambiente de suporte ao ensino

de processamento de imagens usando Python e, por fim, sera ilustrada uma

comparacao de desempenho em relacao a plataforma MATLAB anterior-

mente utilizada.

4.1 Caixa de Ferramentas

De posse do sistema Adesso, ajustado ao desenvolvimento em Python,

foi possıvel criar todas as funcoes, licoes, demonstracoes e testes da caixa

de ferramentas para processamento de imagens, alem de gerar toda a docu-

mentacao correspondente [26, 2]. Sao mais de 60 algoritmos implementados

distribuıdos pelos modulos ia636, ia636demo e ia636test. O prefixo des-

tes nomes vem da sigla da disciplina de Visao Computacional da Unicamp.

Todas as funcoes implementadas tambem recebem prefixo “ia” para facilitar

a identificacao. Espera-se que este pacote sempre incorpore novas funcio-

nalidades. Uma descricao geral de seu estado atual e feita a seguir. A

51

52 CAPITULO 4. RESULTADOS

documentacao mais detalhada pode ser vista nos Apendices C e D.

Foram implementadas diversas licoes:

• Geracao de imagens sinteticas diversas ( iagenimages );

• Funcao de transformacao de contraste ( iait );

• Equalizacao de histograma ( iahisteq );

• Teorema da convolucao ( iaconvteo );

• Tecnica de casamento de padrao ( iacorrdemo );

• Demonstracao do espectro de Fourier para imagens sinteticas simples

( iadftexamples );

• Propriedade de escala da Transformada de Discreta de Fourier

e caracterizacao da forma da matriz nucleo desta transformacao

( iadftscaleproperty e iadftmatrixexamples );

• Decomposicao de imagens em ondas primitivas 2-D ( iadftdecompose );

• Interpolacao de imagens aumentadas ( iamagnify );

• Restauracao pela filtragem inversa ( iainversefiltering );

• Tranformada de Hotelling ( iahotelling );

• Ilustracao do metodo de selecao de thresholding de Otsu ( iaotsudemo ).

Foram implementadas diversas funcoes divididas nos seguintes topicos:

• Criacao de imagem: filtro passa-baixas de Butterworth ( iabwlp ),

cırculo ( iacircle ), impulsos ( iacomb ), cossenoidal 2-D ( iacos ), gaus-

siana 2-D ( iagaussian ), Laplaciano da Gaussiana ( ialog ), bandas verti-

cais com intensidade crescente ( iaramp ) e retangulo ( iarectangle );

4.1. CAIXA DE FERRAMENTAS 53

• Manipulacao e informacao: recorte do retangulo mınimo de uma

imagem ( iacrop ), conversao de ındices lineares para x-y e vice-versa

( iaind2sub e iasub2ind ), criacao de malha 2-D de ındices ( iameshgrid ),

negacao ( ianeg ), normalizacao de intensidades ( ianormalize ), acrescimo

de borda ( iapad ), selecao de uma sub-imagem ( iaroi ) e replicacao ma-

tricial ate uma nova dimensao ( iatile );

• Arquivo de imagens: leitura ( iaread ) e gravacao ( iawrite );

• Manipulacao de constraste: transformacao de intensidades

( iaapplylut ), selecao de mapa de cores ( iacolormap );

• Processamento de cor: true color RGB para imagem de ındices e ta-

bela de cores ( iatcrgb2ind ), conversao RGB-HSV ( iargb2hsv e iahsv2rgb )

e conversao RGB-YCbCr ( iargb2ycbcr e iaycbcr2rgb );

• Manipulacoes geometricas: transformacao afim ( iaffine ), trans-

formacao e escala de corpo rıgido 2-D ( iageorigid ), translacao periodica

( iaptrans ) e redimensionamento ( iaresize );

• Transformacoes: Transformada Discreta de Cossenos ( iadctmatrix e

iadct ), Transformada Discreta de Fourier ( iadftmatrix e iadft ), Trans-

formada Wavelet de Haar ( iahaarmatrix e iahwt ), Transformada de Ha-

damard ( iahadamardmatrix e iahadamard ) e, respectivamente, suas inversas

( iaidct , iaidft , iaihwt e iaihadamard ), alem de funcoes de translacao de

espectro da componente zero ( iafftshift e iaifftshift ) e verificacao de

simetria conjugada ( iaisdftsym );

• Filtragem: filtro do Laplaciano da Gaussiana ( ialogfilter ), contor-

nos de imagens binarias ( iacontour ), convolucao linear e periodica 2-

D ( iaconv e iapconv ), deteccao de borda Sobel ( iasobel ) e filtro de

variancia ( iavarfilter );


• Tecnica de thresholding automatico: Thresholding de Otsu

( iaotsu );

• Medidas: histograma ( iahistogram e iacolorhist ), rotulacao

( ialabel ), reconstrucao de componente conexo ( iarec ) e calculo

do MSE/PSNR/correlacao de Pearson entre duas imagens ( iastat );

• Visualizacao: exibicao da transformada de Fourier ( iadftview ),

exibicao de linhas de nıvel de uma imagem em nıveis de cinza

( iaisolines ), exibicao de uma imagem rotulada com cores aleatorias

( ialblshow ), exibicao de graficos ( iaplot ), exibicao de imagens ( iashow

e iagshow ) e exibicao de superfıcies 3-D ( iasplot );

• Aproximacoes de meio-tom: dithering ordenado ( iadither ) e di-

fusao de erro de Floyd-Steinberg ( iafloyd );

• Funcoes de suporte: documentacao de uma funcao ( iahelp ), exibicao

do codigo-fonte de uma funcao ( iatype ), exibicao de mensagens de erro

( iaerror ) e devolucao do conjunto unico ordenado, sem repeticao, a

partir de um vetor ou matriz de entrada ( iaunique ).

A Figura 4.1 mostra o IDLE1 Python e exemplos simples de uso da caixa

de ferramentas implementada.

Dada uma base de dados XML no Adesso, acrescentar o suporte a outra

linguagem significa basicamente incluir as informacoes de sintaxe em tre-

chos onde ha codigo-fonte, alem de implementar as folhas de estilo para a

interpretacao do novo contexto. As demais informacoes como parametros

de entrada e saıda, descricoes gerais das funcoes e de seus parametros, sao

compartilhadas. Esta caracterıstica facilita a manutencao de uma mesma

caixa de ferramentas para multiplas linguagens. Um resultado importante e

que as mesmas funcionalidades apresentadas aqui, para a caixa de ferramen-

tas ia636, estao disponıveis tambem para a linguagem MATLAB. Python e

1Integrated DeveLopment Environment

4.1. CAIXA DE FERRAMENTAS 55

Figura 4.1: Exemplo de uso da caixa de ferramentas no IDLE Python.

MATLAB seguem, via de regra, uma certa sistematica de intercambeamento

das sintaxes tornando esta manutencao perfeitamente plausıvel. A Tabela 4.1

mostra algumas diferencas de sintaxe, de operacoes usuais em processamento

de imagens, entre as linguagens Python e MATLAB.

Toda a caixa de ferramentas, inclusive codigo-fonte, pode ser obtida a

partir da pagina do projeto do curso de processamento de imagens em Py-

thon [13]. Neste site tambem podem ser conferidos: o programa do curso,

os pontos levantados em uma lista de discussao, referencias bibliograficas,

manual de instalacao do ambiente de programacao, e todas as atividades

recentes entregues pelos alunos.


Operacoes comuns Numerical Python MATLABNumero complexo >>> 1j >> j

Matriz n-dimensional >>> a = zeros((N1,N2,...,Nn)) >> a = zeros(N1,N2,...,Nn)

Matriz quadrada >>> a = zeros((N,N)) >> a = zeros(N)

Criacao de vetor >>> a = zeros(N) >> a = zeros((1,N))

Linearizacao de matriz >>> ravel(a) >> a(:)

Dimensao de matriz >>> a.shape >> size(a)

Primeiro elemento >>> a[0] >> a(1)

Ultimo elemento >>> a[-1] >> a(end)

Slicing >>> a[inicio:fim+1:passo] >> a(inicio+1:passo:fim+1)

Retipagem >>> a.astype(’b’) >> uint8(a)

Redimensionamento >>> reshape(a,new_shape) >> resize(a,new_size)

Transposicao >>> transpose(a) >> a’

Multiplicacao, potenciacao >>> a*b, a**b >> a.*b, a.^b

Multiplicacao de matrizes >>> matrixmultiply(a,b) >> a*b

Concatenacao de matrizes >>> concatenate((a,b)) >> [a;b]

Tabela 4.1: Algumas diferencas de sintaxe entre Numerical Python e MA-TLAB.

4.2 Corretor Automatico

Com auxılio da caixa de ferramentas construıda e das funcionalidades

nativas do Python para implementacao de CGI2 foi possıvel desenvolver um

sistema para processar entregas de exercıcios do alunos, em Python, pela

Internet. Em uma pagina de submissao, e solicitada a entrega de um modulo

(um arquivo) com os prototipos de todas as funcoes precisamente definidos

por um enunciado. Optativamente tambem pode ser entregue um relatorio

(em formato TXT, PS, PDF ou HTML). Este sistema se divide em duas

modalidades:

1. Correcao. Varios testes, dado por um script elaborado pelo professor,

sao feitos sobre o modulo entregue e os resultados obtidos sao compa-

rados com os resultados do processamento do “Modulo Gabarito”. A

Figura 4.2 ilustra este processo. A caixa com o sımbolo “=” se encar-

rega de comparar todas as n variaveis (n testes) em memoria, V1, V2,

. . . Vn, definidas pelo “Script de Testes”, entre os resultados da sub-

missao V(a)i e do gabarito V

(b)i , i ∈ [1, n]. As saıdas sao os resultados

2Common Gateway Interface

4.2. CORRETOR AUTOMATICO 57

V(a)

1

V(a)

2

V(a)n

...V

(b)1

V(b)

2

V(b)n

...= Saídas

Testes

Módulo daSubmissão

GabaritoMódulo

Script de

(a) Esquema do corretor automatico. (b) Exemplo de in-terface das “saıdas”.

Figura 4.2: Esquema do corretor automatico na modalidade de “correcao”.

das comparacoes. E exibido, para cada variavel, se o valor esta correto,

incorreto ou se houve falha. O interesse aqui e verificar a exatidao do

algoritmo do aluno.

2. Visualizacao. Nesta modalidade, nao e necessaria a implementacao

de um gabarito. Sao feitos testes sobre o modulo submetido, da mesma

forma, e uma pagina HTML, com saıdas numericas ou imagens, e ge-

rada automaticamente e armazenada como resultados de cada aluno,

conforme especificacoes feitas no script de testes. A Figura 4.3 ilustra

o ambiente de interacao inicial de submissao dos exercıcios e alguns

resultados gerados neste sentido. O interesse aqui poderia ser, entre

outros, o de verificar a qualidade ou forma de uma imagem produzida

por um algoritmo, um ındice de correlacao ou de erro.

Para o professor ha ainda uma opcao de consulta detalhada dos resul-

tados que pode ser acessada a qualquer tempo (os alunos nao tem esta

permissao antes do prazo de entrega). Alem do codigo-fonte, relatorio,


Figura 4.3: Ambiente de submissao e visualizacao de resultados.

resultados ilustrativos em HTML ou historico de testes realizados, o

professor tambem pode visualizar os tempos de execucao de cada funcao

submetida, aluno por aluno, permitindo, desta forma, uma analise de

eficiencia das implementacoes. O sistema ainda permite a re-submissao

de todos os modulos entregues, caso se queira estabelecer novos testes,

e producao de um arquivo compactado de todos os resultados.

O corretor agregou recentemente o recurso de construcao on line de wrap-

pers , a partir de um script Python desenvolvido pelo Rubens C. Machado

do CenPRA. Com algumas regras de programacao bem documentadas pelo

Rubens e possıvel que os alunos tambem enviem programas em C. O cor-

retor, neste caso, recebe o codigo, realiza a compilacao, exibe os resultados

da mesma e, se nao houver erro, cria um modulo com as funcoes built-in do

aluno que, a partir deste momento, passam a ser tratadas normalmente em

qualquer das modalidades do corretor.

4.3. AVALIACAO 59

4.3 Avaliacao

O ambiente de programacao, incluindo o uso da caixa de ferramentas e

o sistema de correcao automatica, foi utilizado no curso de Visao Computa-

cional (IA636) da pos-graduacao da Unicamp, sendo que, pela primeira vez,

o Prof. Roberto Lotufo experimentou o uso exclusivo da linguagem Python.

Diversas atividades foram feitas [13]: (1) Sıntese de Imagem em Forma de

Xadrez; (2) Ferramentas de Manipulacao de Imagens; (3) Sıntese de Ima-

gens e Histograma; (4) Sıntese e Combinacao de Imagens e Modelos de Cor;

(5) Transformacoes Geometricas; (6) Convolucao Linear, Verificacao de Con-

jugado Simetrico, Manipulacao Geometrica; (7) Sıntese de Imagens, Filtro

Gaussiano e Propriedades de Transformadas; (8) Transformada de Hotelling;

(9) Codificacao JPEG; (10) Projeto de Contagem de Laranja. Ao final do

curso foi proposto um questionario on line de avaliacao do ambiente de su-

porte (sem que uma mesma maquina pudesse responder mais de uma vez).

De treze alunos matriculados, doze questionarios foram respondidos. Os re-

sultados sao mostrados na Tabela 4.2.

Ainda tres comentarios gerais foram feitos pelos alunos:

(1) “Considero que, por estar em fase de implementacao, o sistema de corre-

tor automatico ainda precisa de alguns ajustes (embora uma boa parte

dos problemas encontrados seja derivada dos proprios problemas da

linguagem Python)”

(2) “O ambiente gera uma situacao interativa entre alunos e professor, o que

torna a cadeira mais dinamica e mais do que ficar entre quatro paredes

de uma sala de aula. O importante e aplicar e conhecer como as coisas

funcionam e nao so ficar na teoria. Essa e a vantagem desse curso.”

(3) “A linguagem python/numeric e uma ferramenta simples para ser uti-

lizada com processamento de imagens, devido a maneira com que ela

trabalha com matrizes. O processo de aprendizado da linguagem e facil

e intuitivo.”


Perguntas e numero de respostas por alterna-

tiva

Proporcao

1

Quanto tempo aproximadamente voce levou para instalar

o Python e todos os pacotes necessarios ao funcionamento

da toolbox IA636? (a) Em poucos minutos: 8; (b) Em

poucas horas: 2; (c) Em cerca de um dia: 0; (d) Em cerca

de uma semana: 1; (e) Em mais de uma semana: 1

2

Quanto tempo aproximadamente voce levou para se ha-

bituar a sintaxe Python e Numerical? (a) Menos de duas

semanas: 5; (b) Entre duas semanas e um mes: 5; (c)

Mais de um mes: 2

3Como foi a programacao Python/Numeric no inıcio do

curso? (a) Muito difıcil: 2; (b) Difıcil: 0; (c) Normal: 7;

(d) Facil: 1; (e) Muito facil: 2

4Como foi a programacao Python/Numeric no final do

curso? (a) Muito difıcil: 1; (b) Difıcil: 2; (c) Normal:

3; (d) Facil: 5; (e) Muito facil: 1

5

Como voce situa o Python/Numeric como ferramenta

para um curso de processamento de imagens? (a) Nao e

adequada: 0; (b) E pouco adequada: 5; (c) E adequada:

3; (d) E muito adequada: 4

6Qual a avaliacao geral sobre as implementacoes da tool-

box IA636? (a) Ruins: 0; (b) Razoaveis: 3; (c) Boas: 8;

(d) Excelentes: 1

7Qual a sua avaliacao geral sobre a toolbox IA636? (a)

Ruim: 0; (b) Razoavel: 3; (c) Boa: 9; (d) Excelente: 0

8Qual sua avaliacao geral sobre o sistema de correcao au-

tomatica? (a) Nao e adequado: 0; (b) E pouco adequado:

4; (c) E adequado: 3; (d) E muito adequado: 5

9Qual sua avaliacao geral sobre o ambiente de suporte ao

curso IA636? (a) Ruim: 1; (b) Razoavel: 0; (c) Bom: 8;

(d) Excelente: 3

Tabela 4.2: Avaliacao do ambiente de suporte a processamento de imagens.

4.4. MORFOLOGIA MATEMATICA 61

Considerando que o corretor foi desenvolvido durante o curso, onde os

proprios alunos serviram como testadores do sistema desenvolvido, estes re-

sultados foram considerados bastante satisfatorios.

4.4 Morfologia Matematica

O suporte a criacao de API Python/C feito no sistema Adesso (vide

Subsecao 3.2.4) permitiu que a caixa de ferramentas de Morfologia Ma-

tematica [4], integralmente programada em C, pudesse ser diretamente por-

tada em Python. Estas ferramentas ja eram utilizadas nas plataformas Kho-

ros, Tcl e MATLAB. Os alunos do curso de Morfologia Matematica (IA870)

da pos-graduacao da Unicamp, segundo semestre de 2002, passaram a usa-la

tambem em Python. A vantagem mais imediata talvez venha da agilidade

proporcionanda pelo ambiente de suporte a processamento de imagens im-

plementado, ou da flexibilidade da propria linguagem. Em Tcl, por exemplo,

qualquer operacao matricial nao prevista pela caixa de ferramentas, necessita

ser implementada em C. MATLAB, apesar de excelente ao que se propoe, e

fechada e dificulta a implementacao de sistemas, por exemplo, para Internet.

Com Khoros, ha complicacoes parecidas.

Para ilustrar o funcionamento do morph, nome dado ao modulo princi-

pal API gerado, e descrito na Figura 4.4 uma aplicacao de segmentacao de

microestruturas do concreto utilizado na construcao civil. A imagem origi-

nal de microscopia eletronica por varredura (SEM) e algumas das saıdas da

funcao concrete apresentada podem ser visualizadas a direita. Sao estas:

(i) anidros - compostos do cimento nao hidratados; (ii) agregados - outros

compostos nao pertecentes ao cimento como como areia, pedra ou escoria; e

(iii) compostos hidratados do cimento. Esta implementacao resultou em um

artigo aceito no SIBGRAPI 2002 [25]. As funcoes de morfologia utilizadas

sao: (1) mmhistogram - calculo eficiente de histograma de uma imagem; (2)

mmasf - filtragem alternada sequencial; (3) mmneg - negativo de uma ima-


def concrete(file=’concrete.pgm’, hm=20): from Numeric import nonzero, ravel, sum from ia636 import iaread, iashow from morph import mmhistogram, mmasf, mmneg, mmseline,\ mmwatershed, mmbinary, mmintersec, mmframe,\ mmthreshad, mmareaopen, mmgradm, mmregmin,\ mmhbasin, mmcwatershed, mmareaclose, mmsubm f = iaread(file)

# Segmentacao dos Anidros hf = mmhistogram(f) hasf = mmasf(mmneg(hf),’co’,mmseline(8,90)) ws = mmwatershed(hasf) wsf = mmintersec(mmneg(mmbinary(−mmframe(ws,0,20))), ws) kth = nonzero(ravel(wsf)) aux = mmthreshad(f,kth,255) anhy = mmareaopen(aux,20)

# Segmentacao dos Agregados grad = mmgradm(f) ma = mmregmin(mmhbasin(grad,hm)) wsa = mmcwatershed(grad,ma) a1 = mmareaopen(mmneg(wsa),300) a2 = mmareaclose(a1,50) aggr = mmsubm(a2,anhy)

# Componente Hidratado hydcomp = mmsubm(f,a2)

# Fracao de Area (h,w) = f.shape aanhy = 1.*sum(ravel(anhy))/(w*h) aaggr = 1.*sum(ravel(aggr))/(w*h)

return (anhy, aanhy, aggr, aaggr, hydcomp)

Imagem original (f)

Anidros (anhy)

Agregados (aggr)

Compostos hidratados

(hydcomp)

Figura 4.4: Aplicacao de segmentacao de microestruturas do concreto.

gem; (4) mmseline - criacao de elemento estruturante em forma de linha; (5)

mmwatershed - deteccao de linhas divisoras de agua [5, 28]; (6) mmbinary -

conversao de uma imagem em nıveis de cinza em uma imagem binaria; (7)

mmintersec - interseccao de imagens; (8) mmframe - criacao de um quadro

ao redor de uma imagem; (9) mmthreshad - thresholding adaptativo; (10)

mmareaopen - abertura por area; (11) mmgradm - gradiente morfologico; (12)

mmregmin - mınimo regional; (13) mmhbasin - remocao de bacias com con-

traste menor que um certo valor; (14) mmcwatershed - deteccao de linhas

divisoras de agua por marcadores; (15) mmareaclose - fechamento por area;

(16) mmsubm - subtracao de duas imagens com saturacao.

4.5 Python x MATLAB

Nesta secao, sao feitos alguns testes em que sao medidos os tempos medios

de execucao (em um Athlon XP 1.4GHz), sob mesmas condicoes, de funcoes

diretas built-in e tambem da caixa de ferramentas implementada ia636.

Cada teste e repetido sobre imagens diferentes imagens, de 256x256, 512x512,

4.5. PYTHON X MATLAB 63

640x480 e 800x600. A Figura 4.5 se refere aos tempos calculados para as se-

guintes funcoes built-in: alocacao de memoria, iteracao para construcao de

uma imagem sintetica, uso de malha de ındices tambem para construcao da

mesma imagem sintetica, transposicao matricial, linearizacao, espelhamento

na horizontal e vertical, negacao (255 menos os valores da imagem criada),

potenciacao de todos elementos da imagem, multiplicacao de matrizes, con-

catenacao na horizontal e vertical (aumento de 4 vezes), soma de todos os

elementos da matriz linearizada, calculo da Transformada Rapida de Fou-

rier (FFT), e inversao de matriz. Para imagens de 640x480 e 800x600 nao se

aplica a multiplicacao ou inversao de matrizes entre si. Observa-se que, como

ja foi dito, o uso de iteracoes sobre estruturas matriciais e mais eficiente em

Python, sendo, em geral, menos da metade do tempo obtido em MATLAB.

Outra consideracao a fazer e o desempenho da multiplicacao de matrizes.

Neste caso, a implementacao do Numerical e bastante ineficiente em relacao

a do MATLAB. Os demais testes se mostram equilibrados, bastante rapidos

e, exceto na inversao de matriz, sempre inferiores a 1s de execucao.

A Figura 4.6 compara os tempos de execucao de algumas das funcoes

ia636 implementadas. Os testes mais crıticos aqui sao iadct e iadft que

se utilizam de multiplicacao de matrizes, ponto fraco da implementacao do

Numerical vista anteriormente. Para o calculo da DFT existe a opcao ime-

diata built-in bastante eficiente em ambas linguagens. No caso da DCT, o

ideal seria a implementacao do algoritmo e wrapper em C. Outra funcao em

evidencia e a iaotsu. Nesta e preciso calcular o histograma da imagem,

implementacao crıtica em linguagens interpretadas por necessitar de uso de

comandos de iteracao. Outra funcao bastante iterativa e a ialabel. Sua im-

plementacao em Python, no entanto, utilizou-se, na maior parte do codigo, de

estruturas nativas do Python, demonstrando-se bastante eficiente (destaque

a diferenca obtida pelo ialabel na Figura 4.6(d)). As demais funcoes apre-

sentam execucoes relativamente eficientes tanto para Python quanto para

MATLAB.


(a) (b)

(c) (d)

Figura 4.5: Comparacoes de desempenho de funcoes built-in entre Python eMATLAB.

4.5. PYTHON X MATLAB 65

(a) (b)

(c) (d)

Figura 4.6: Comparacoes de desempenho de funcoes ia636 entre Python eMATLAB.


A conclusao imediata deste trabalho e que a implementacao nativa do

Python, em termos de eficiencia, e superior a do MATLAB. Ja a imple-

mentacao dos modulos do pacote Numerical e, em geral, inferior a do MA-

TLAB. A equipe de desenvolvimento do Numerical esta reescrevendo o codigo

e incluindo mais funcoes em baixo nıvel com o proposito de que o pacote,

agora chamado de numarray, mais otimizado, passe a integrar futuras distri-

buicoes Python. Enquanto isto, vale citar alguns detalhes que comprometem

ou melhoram o desempenho da implementacao de scripts pelo usuario. Por

exemplo, para os parametros de entrada, e comum que se aceite listas do

Python ou arrays do Numeric e, independentemente da entrada, se faca a

retipagem para array . Isto e custoso para imagens grandes. Aconselha-se

usar a funcao Numeric.asarray em vez de Numeric.array pois, neste caso,

nao ha alocacao de mais memoria caso a entrada ja seja um array . Em

MATLAB, tal problema nao se aplica pois e utilizado apenas um tipo de

estrutura. Outra questao, que ajuda consideravelmente no desempenho do

Numerical, e a utilizacao de referencia a elemento da matriz na forma A[i][j][k]

em vez de A[i,j,k]. As funcoes numericas (seno, tangente, logaritmo, poten-

ciacao, ...) do modulo nativo math do Python tambem sao mais eficientes

que as do modulo Numeric, porem nao podem ser aplicadas a conjunto de

dados, a menos que sejam usadas iteracoes ou comandos como map (imple-

menta iteracao implıcita). O tratamento usual de erros e excecoes e outra

caracterıstica que faz com que o desempenho em Python fique comprome-

tido em relacao ao MATLAB mas, por outro lado, aumenta a flexibilidade

do codigo. Todas estas consideracoes, no entanto, perdem sentido quando

ha uma mesma implementacao em baixo nıvel para Python e MATLAB. E

o caso da caixa de ferramentas de morfologia matematica. Para wrappers a

eficiencia e comparavel ao assembly da maquina.

Capıtulo 5

Consideracoes Finais

5.1 Conclusoes

Python e uma linguagem generica podendo, portanto, ser usada em varios

domınios de aplicacao. Existem diversos modulos que vem juntos a sua dis-

tribuicao (de funcoes matematicas, de manipulacao de strings e tempo, de

utilizacao de sistemas operacionais e de arquivos, de compactacao, criptogra-

fia, de suporte SGML, CGI, HTTP, FTP, Telnet, apenas para citar alguns)

e inumeros outros que podem ser incorporados. Como exemplo, pode-se

destacar o poderoso PyOpenGL (interface encapsulada da implementacao

OpenGL). Este modulo vem sendo utilizado com sucesso por grande parte

do alunos do curso de pos-graduacao de Computacao Grafica da FEEC-

Unicamp. O pacote Numerical, em especial, se adapta perfeitamente ao

proposito deste trabalho que e o de manipulacao matricial de grandes con-

juntos de dados, de forma eficiente, para o processamento de imagens.

O sistema Adesso separa nitidamente conteudo de apresentacao simpli-

ficando consideravelmente o esforco de manutencao e gerenciamento da in-

formacao de uma caixa de ferramentas, um processo bastante trabalhoso de-

vido ao elevado numero de componentes (que tende a aumentar). A adocao

da metodologia de estruturar a informacao e usar geracao de codigo e docu-

67

68 CAPITULO 5. CONSIDERACOES FINAIS

mentos de forma automatizada traz inumeros benefıcios sendo os principais:

diminuicao do numero de linhas de informacao mestre, responsavel tanto pelo

programa como sua documentacao geradas, aumentando imunidade a erros

(tipicamente introduzidos em situacoes de “copia e cola”), diminuindo espaco

de armazenamento de copias de seguranca; consistencia na interface com o

usuario, visto que o codigo resultante e gerado automaticamente, sendo ine-

rentemente sistematico por todo o sistema; informacao facilmente adaptavel

para gerar codigo e documentacao de acordo com os avancos tecnologicos

exigidos pelo mercado; maior imunidade a erros tambem na criacao de um

empacotamento e distribuicao do aplicativo, permitindo uma consistencia na

configuracao desejada.

A caixa de ferramentas desenvolvida e capaz de suprir boa parte das neces-

sidades basicas quando na implementacao de um exercıcio de processamento

de imagens. A grande quantidade de exemplos da documentacao gerada au-

xilia fortemente o aprendizado da linguagem Python em si e, principalmente,

dos algoritmos tradicionais de tratamento de imagens. As codificacoes utili-

zando tanto o Numerical Python quanto o MATLAB revelam-se, em geral,

implementacoes diretas das formulas estudadas nos livros.

O corretor automatico mostrou-se uma ferramenta eficaz no auxılio a

avaliacao de exercıcios de programacao, alem de permitir a visualizacao e

comparacao das solucoes pelos codigos entregues e resultados gerados.

A principal vantagem do Python sobre o Tcl e prover um sistema eficiente

direto de manipulacao de matrizes. Em Tcl qualquer operacao neste sentido

necessita de implementacoes em C. Python tambem permite que todo o tra-

balho feito possa ser utilizado de diversas maneiras, desde aplicacoes para

Internet como em sistemas stand alone (com chamadas ao interpretador em-

butidas). Com MATLAB, tarefas assim, em geral, nao tem suporte explıcito

e dependem dos termos de registro do software para serem realizadas. Lin-

guagens como Octave [8] e Scilab [6] que, a primeira vista, poderiam ser

opcoes imediatas, gratuitas e compatıveis ao MATLAB, demonstram-se bas-

5.2. TRABALHOS FUTUROS 69

tante dedicadas a problemas de computacao cientıfica, sao menos flexıveis em

relacao ao Python, e suas comunidades nao apresentam uma atividade tao

intensa de desenvolvimento como a observada nas atualizacoes, melhoramen-

tos constantes e inclusao de novas funcionalidades da linguagem Python. Por

ser baseado em Python, o ambiente de suporte a processamento de imagens

implementado e totalmente disponibilizado de forma gratuita e modificacoes

de qualquer especie podem ser feitas a qualquer momento conforme a ne-

cessidade. O facil acesso as instalacoes, a flexibilidade de programacao em

funcao do desempenho requerido, os resultados da aplicacao pratica sentido

na exposicao de opinioes pelos alunos, indicam que o presente trabalho pas-

sou de fato a ser uma ferramenta auxiliar no aprendizado de processamento

de imagens, permitindo uma visualizacao rapida dos resultados esperados

teoricamente. O mesmo pode perfeitamente ser utilizado em atividades de

pesquisa e construcao de aplicacoes finais.

5.2 Trabalhos Futuros

Como trabalho futuro, poderıamos citar a criacao de folhas de estilo,

dentro do sistema Adesso, para facilitar a geracao de paginas dinamicas na

Internet. Poder-se-ia ter um ambiente on line de testes de funcoes, onde, a

priori, e desnecessaria a instalacao da caixa de ferramentas (o interpretador

seria transparente do lado do servidor). A Figura 5.1 exibe um prototipo

neste sentido construıdo manualmente para o calculo do filtro de media,

onde o aluno pode escolher a imagem de entrada e a dimensao da mascara.

A saıda e entao visualizada ao lado da imagem original. Todo este processo

depende simplesmente de um navegador de Internet. O formulario com as

opcoes de escolha poderia ser montado conforme a documentacao de tipos

registrada na base de dados XML.

Um trabalho possıvel seria o de implementar um sistema de programacao

visual similar ao Khoros ou Simulink. Assim como na descricao encadeada de

70 CAPITULO 5. CONSIDERACOES FINAIS

Figura 5.1: Calculo on line do filtro de media usando CGI/Python e a caixade ferramentas ia636.

instrucoes em um script , ter-se-ia agora um encadeamento de componentes

graficos (drag and drop), cada um com as devidas entradas e saıdas. Todas

as informacoes necessarias neste sistema estao disponıveis nos documentos

XML. Um parser XML para Python, associado a uma interface GUI Tkinter

ou wxPython, poderia ser usado com este proposito. Quando se trata de

interfaces graficas, Java e uma ferramenta bastante requisitada. E applets

Java permitem o uso destes recursos graficos tambem remotamente (pela

Internet). A exploracao da linguagem Jython1 seria interessante por agregar

o uso de modulos Python normalmente e as vantagens do uso de interfaces

em Java.

Outro trabalho que vem sendo desenvolvido pelo Guilherme S. Maz-

zela [11] e o de portar, em Python, a aplicacao Prontovideo [16], ate entao

programada em Tcl. O benefıcio principal seria aquele que foi comentado no

final da secao anterior.

1http://www.jython.org

Referencias Bibliograficas

[1] A. C. R. Almeida, A. A. S. Sol e A. A. Araujo. PhotoPixJ: uma Plata-

forma para Processamento Digital de Imagens em Java. In Proceedings

of the SIBGRAPI, Rio de Janeiro, Brazil, October 1998. IEEE.

[2] A. G. Silva, R. A. Lotufo e R. C. Machado. Ambiente de Suporte ao

Ensino de Processamento de Imagens Usando a Linguagem Python. In

XIII SBIE, pages 39–48, Sao Leopoldo, Brasil, Novembro 2002. Unisinos.

[3] D. Ascher, P. F. Dubois, K. Hinsen, J. Hugunin, and T. Oliphant. Nu-

merical Python. September 2001.

http://www.pfdubois.com/numpy/html2/numpy.html.

[4] J. Barrera, G. J. F. Banon, R. A. Lotufo, and R. Hirata Jr. MMach: a

Mathematical Morphology Toolbox for the Khoros System. Journal of

Electronic Imaging, 7(1):174–210, 1998.

[5] S. Beucher and F. Meyer. Mathematical Morphology in Image Proces-

sing, chapter 12. The Morphological Approach to Segmentation: The

Watershed Transformation, pages 433–481. Marcel Dekker, 1992.

[6] J.-P. Chancelier, F. Delebecque, C. Gomez, M. Goursat, R. Nikoukhah,

and S. Steer. Introduction a SCILAB. Springer, 2002.

[7] R. C. Machado e R. A. Lotufo. Adesso: Ambiente Computacional para

Desenvolvimento Rapido de Aplicacoes. Technical report, DCA-FEEC-

Unicamp/FCTI, Campinas, Brasil, Maio 2000.

71

72 REFERENCIAS BIBLIOGRAFICAS

[8] J. W. Eaton. GNU Octave, a high-level interactive language for nume-

rical computations. 3rd edition, February 1997.

http://www.octave.org/doc/octave toc.html.

[9] S. L. Eddins and M. T. Orchard. Using MATLAB and C in an Image

Processing Lab Course. In Proceedings of ICIP-94, pages 515–519, Aus-

tin, USA, November 1994.

[10] J. L. Fontaine. tclpython, a Python package for Tcl.

http://jfontain.free.fr/tclpython.htm.

[11] G. S. Mazzela e R. A. Lotufo. Ferramenta de Segmentacao Interativa de

Imagens e Vıdeo Usando Python-Numeric-Tk. In X Congresso Interno

de Iniciacao Cientıfica da Unicamp, Campinas, 2002.

[12] R. C. Gonzalez and R. E. Woods. Digital Image Processing. Addison-

Wesley Publishing Company, 1992.

[13] ia636. Course of Image Processing in Python. 2002.

http://www.dca.fee.unicamp.br/˜alexgs/curso.

[14] L. Jochen. tDOM - A fast XML/DOM/XPath package for Tcl written

in C. 1999. http://sdf.lonestar.org/˜loewerj/tdom.cgi.

[15] R. Jordan and R. A. Lotufo. Interactive Digital Imagem Processing

Course on the World-Wide Web. In Proceedings of the 1996 Internatio-

nal Conference on Image Processing, pages 433–436, Lausanne, Switzer-

land, September 1996. IEEE Signal Processing Society.

[16] R. Lotufo, R. Machado, F. Flores, A. Falcao, R. Koo, G. Mazzela, and

R. Costa. Prontovideo - An Image Sequence Segmentation Tool Ap-

plied to Video Edition. In Proceedings of XIV SIBGRAPI, page 404,

Florianopolis, Brazil, October 2001. IEEE Signal Processing Society.

REFERENCIAS BIBLIOGRAFICAS 73

[17] R. A. Lotufo and R. Jordan. Hands-On Digital Image Processing. In

IEEE Fontiers in Education – 26th Annual Conference, pages 1199–1202,

Salt Lake City, USA, November 1996. FIE-96.

[18] F. Lundh and M. Ellis. Python Imaging Library Handbook. March 2002.

http://www.pythonware.com/products/pil/pil-handbook.pdf.

[19] R. M. S. Luppi, D. M. Kligerman, A. X. Falcao, U. M. B. Neto, and

R. A. Lotufo. V3DTOOLS: A KHOROS Toolbox for 3D Imaging. In

Word Congress on Medical Physics and Biomedical Engineering, Rio de

Janeiro, Brazil, August 1994.

[20] M. Lutz and D. Ascher. Learning Python. O’Reilly & Associates, April

1998.

[21] R. C. Machado. Adesso: Ambiente para Desenvolvimento de Software

Cientifico. Dissertacao de Mestrado, Faculdade de Engenharia Eletrica

e de Computacao - Universidade Estadual de Campinas, Junho 2002.

[22] L. Prechelt. An Empirical Comparison of Seven Programming Langua-

ges. Computing Pratices IEEE, pages 23–29, October 2000.

[23] J. A. Robinson. A Software System for Laboratory Experiments in

Image Processing. IEEE Transactions on Education, 43:455–459, No-

vember 2000.

[24] G. Rossum. Python Tutorial. 2002.

http://www.python.org/doc/current/tut/tut.html.

[25] A. G. Silva, R. A. Lotufo, and F. C. Flores. Classification of Micros-

tructures by Morphological Analysis and Estimation of the Hydration

Degree of Cement Past in Concrete. In Proceedings of XV SIBGRAPI,

pages 138–145, Fortaleza, Brazil, October 2002. IEEE Signal Processing

Society.


[26] A. G. Silva, R. A. Lotufo, and R. C. Machado. Toolbox of Image Proces-

sing for Numerical Python. In Proceedings of XIV SIBGRAPI, page 402,

Florianopolis, Brazil, October 2001. IEEE Signal Processing Society.

[27] SDC Information Systems. SDC Morphology Toolbox for MATLAB.

1998. http://www.mmorph.com.

[28] L. Vincent and P. Soille. Watersheds in Digital Spaces: An Efficient Al-

gorithm Based on Immersion Simulations. IEEE Transactions on Pat-

tern Analysis and Machine Intelligence, 13(6):583–598, June 1991.

[29] W3C Recommendation 16 November 1999. XML Path Language

(XPath) 1.0. 1999. http://www.w3.org/TR/xpath.

[30] W3C Recommendation 16 October 1998. Document Object Model

(DOM) Level 1 Specification Version 1.0. 1998.

http://www.w3.org/TR/REC-DOM-Level-1.

[31] W3C Recommendation 6 October 2000. Extensible Markup Language

(XML) 1.0. 2000. http://www.w3.org/TR/2000/REC-xml-20001006.

[32] W3C Working Draft 27 March 2000. Extensible Stylesheet Language

(XSL) 1.0. 2000. http://www.w3.org/TR/xsl.

[33] N. Walsh and L. Muellner. DocBook: The Definitive Guide. O’Reilly &

Associates, 1999.

[34] B. B. Welch. Pratical Programming in Tcl and Tk. Prentice Hall PTR,

3rd edition, 1999.

[35] T. Williams and C. Kelley. gnuplot, An Interactive Plotting Program.

December 1998. http://www.ucc.ie/gnuplot/gnuplot.html.

Trabalhos Publicados

[1] A. G. Silva, R. A. Lotufo e R. C. Machado. Ambiente de Suporte ao

Ensino de Processamento de Imagens Usando a Linguagem Python. In

XIII SBIE, pages 39-48, Sao Leopoldo, Brasil, Novembro 2002. Unisinos.

[2] A. G. Silva, R. A. Lotufo, and R. C. Machado, Toolbox of Image Proces-

sing for Numerical Python. In Proceedings of XIV SIBGRAPI, page 402,

Florianopolis, October 2001. IEEE Signal Processing Society.

[3] A. G. Silva, R. A. Lotufo, and F. C. Flores. Classification of Micros-

tructures by Morphological Analysis and Estimation of the Hydration

Degree of Cement Past in Concrete. In Proceedings of XV SIBGRAPI,

pages 138-145, Fortaleza, Brazil, October 2002. IEEE Signal Processing

Society.

[4] F. C. Flores, R. A. Lotufo, S. Isernhagen, L. M. Rocha, A. G. Silva,

and E. F. Rocha. Method for Assessment of Telangiectasia Degreeing by

Mathematical Morphology. In Proceedings of XV SIBGRAPI, pages 153-

160, Fortaleza, Brazil, October 2002. IEEE Signal Processing Society.

75

Apendice A

Implementacoes de MSE

Segue a listagem dos programas usados na determinacao do MSE (Mean

Square Error ou Erro Medio Quadratico) entre duas imagens f1 e f2, para

as linguagens C, Java, Python e MATLAB. Os tempos de execucao de cada

funcao, dada uma imagem colorida 256x256 pixels, foram calculados e os

resultados mostrados na Tabela 2.1 para comparacao.

A.1 Em C

double mse(image f1, image f2) {

int h = f1.h;

int w = f1.w;

int i;

double MSE = 0;

for (i=0; i < 3*h*w; i++) {

MSE = MSE + pow((f1.data[i] - f2.data[i]), 2);

}

MSE = MSE / (3*h*w);

return MSE;

}

A.2 Em Java

public double mse(int f1[], int f2[], int h, int w) {

77

78 APENDICE A. IMPLEMENTACOES DE MSE

double MSE=0;

for (int i=0; i < h*w; i++) {

int R1, R2, G1, G2, B1, B2;

B1 = f1[i] & 255; B2 = f2[i] & 255;

G1 = (f1[i]>>8) & 255; G2 = (f2[i]>>8) & 255;

R1 = (f1[i]>>16) & 255; R2 = (f2[i]>>16) & 255;

MSE = MSE + Math.pow((R1-R2),2) + Math.pow((G1-G2),2) + Math.pow((B1-B2),2);

}

MSE = MSE / (3*h*w);

return MSE;

}

A.3 Em Python

def mse_1(f1, f2):

MSE = 0.

for i in range(f1.shape[0]):

for j in range(f1.shape[1]):

MSE = MSE + (f1[i,j] - f2[i,j])**2

MSE = MSE / (3*f1.shape[0]*f1.shape[1])

return MSE

def mse_2(f1, f2):

from Numeric import ravel, sum, product

MSE = sum((ravel(f1)-ravel(f2))**2.)/(3*product(f1.shape[:2]))

return MSE

A.4 Em MATLAB

function MSE = mse_1(f1, f2)

MSE = 0;

for i = 1:size(f1,1)

for j = 1:size(f1,2)

for k = 1:3

MSE = MSE + (f1(i,j,k) - f2(i,j,k))^2;

end

end

end

MSE = MSE / (3*size(f1,1)*size(f1,2));

function MSE = mse_2(f1, f2)

aux = size(f1);

MSE = sum((f1(:)-f2(:)).^2)/(3*prod(aux(1:2)));

Apendice B

Exemplo de Folha de Estilo

A seguir, e dado um exemplo de uma folha de estilo implementada para

geracao de codigo-fonte Python puro.

stylesheet python.pycode:

template AdToolbox.begin:

[sty:par release check all]

[sty:logIt "------------------"]

[sty:logIt "Processing toolbox ’[att name]’ with pycode stylesheet for PYTHON"]

[sty:save [att name].py {[pythonify [sty:apply . module]]}]

[sty:save [att name]demo.py {[pythonify [sty:apply . demo]]}]

[sty:save [att name]test.py {[sty:apply . suite]}]

template AdToolbox.module:

"""

Module [att name] -- [sty:value @title]

-------------------------------------------------------------------

[sty:foreach Documentation -trim "\n\t " {

[formatPara [sty:apply * ascii] 76 \t]

}]

-------------------------------------------------------------------

[sty:foreach [_sortNodes [concat [sty:compiled exposedTbxCFuns] [sty:compiled exposedTbxPyFuns]] @_id]

-trim "\n\t " -connect "\n\t" {

[format "%-[sty:value /AdToolbox/@_maxlen]s" [sty:call fun python]]

-- [formatPara1 "[sty:value Short]" [expr 80 - [sty:value /AdToolbox/@_maxlen]

- 8] 0 [expr [sty:value /AdToolbox/@_maxlen] + 8]]

}]

"""

#

__version__ = [att major].[att minor]

#

[sty:iff {[llength [sty:compiled exposedTbxCFuns]] > 0} {from _[att name] import *}]

#

[sty:apply [sty:compiled exposedTbxPyFuns] def -trim "\n\t " -connect \n]

79

80 APENDICE B. EXEMPLO DE FOLHA DE ESTILO

#

#

# =====================================================================

# Adesso -- Generated [clock format [clock seconds]]

# =====================================================================

#

-------------------------------------------------------------------

function defs

-------------------------------------------------------------------

template AdFunction.def:

[sty:if {string(Source[@lang="python"])} {

# =====================================================================

#

# Global statements for [sty:call fun python]

#

# =====================================================================

[sty:value {Source[@lang="python"]}]

}]

# =====================================================================

#

# [sty:call fun python]

#

# =====================================================================

def [sty:call fun python]([sty:apply Args/Arg args -connect ", "]):

[tabify [sty:call pyfun docstring] \t]

[tabify [sty:apply Dependencies/Module {} -connect \n] \t]

[tabify [sty:value {Source[@lang="python"]/Code}] \t]

[sty:if Return {return [sty:foreach Return -connect ", " {[join [att name] ", "]}]}]

#

template Args/Arg.args:

[sty:if @optional="yes" {[att name]=[fixDefault [att default]]} else {[att name]}]

template Module:

[sty:if .="" {import [att name] \n} else {from [att name] import [join [sty:value .] ", "]}]

template PYcode.examples:

#

[sty:iff {[llength [sty:nodelist]] > 1} {

# example [sty:index + 1]

#

}]

[sty:apply * ascii]

macro python.demodocstring:

from [sty:value /AdToolbox/@name] import *

print

print ’’’[formatPara [sty:value Short] 68 ""]’’’

print

print

template AdToolbox.demo:

[sty:apply [sty:compiled exposedTbxPyDemos] demo -trim "\n\t " -connect \n]

template AdDemo.demo:

# =========================================================================

#

# [sty:call fun python]

#

# =========================================================================

81

def [sty:call fun python]():

[tabify [sty:call python demodocstring] \t]

[tabify [sty:apply Source/Slide demo] \t]

[tabify "return" \t]

template Slide.demo:

#

print ’=========================================================================’

print ’’’\n[formatPara [sty:value Descr] 68 ""]\n’’’

print ’=========================================================================’

#[regsub -all "showfig" [sty:value {Code[@lang="python"]}] "#showfig" aux]

print ’’’\n$aux’’’

$aux

print

raw_input(4*’ ’+’Please press return to continue...’)

print

print

#

template AdToolbox.suite:

import Numeric

from [sty:value @name] import *

print

print ’’’Testsuite [att name] -- [sty:value @title]’’’

[sty:apply [sty:compiled exposedTbxPySuites] suite -trim "\n\t " -connect \n]

template AdFunction.suite:

print

print ’=====================================================================’

print ’’’[formatPara "[sty:value @name] - [sty:value Short]" 68 ""]’’’

print ’=====================================================================’

[sty:foreach Testsuite {[sty:value {Code[@lang="python"]}]}]

# =====================================================================

# Support Tcl Procedures

# =====================================================================

:adesso:

proc tabify {txt pre} {

regsub -all {\n+} $txt "\n$pre" txt

return $txt

}

proc pythonify {txt} {

set txt [textutil::untabify2 $txt 4]

regsub -all {\n\s*\n} $txt "\n" txt

return $txt

}

proc fixDefault {txt} {

switch -exact -- $txt {

NULL {

set txt None

}

}

return $txt

}

82 APENDICE B. EXEMPLO DE FOLHA DE ESTILO

Apendice C

Functions

C.1 Image Creation

C.1.1 iabwlpPurpose: Low-Pass Butterworth frequency filter.

Synopsis: H = iabwlp(fsize, tc, n, option=’circle’)

Input:fsize <type ’array’> Filter size: a col vector: first element: rows, second: cols,

etc. uses same convention as the return of size.tc <type ’float’> Cutoff periodn <type ’float’> filter order

option <type ’str’> ’circle’ or ’square’

Output:H <type ’array’> DFT mask filter, with H(0,0) as (u,v)=(0,0)

Description: This function generates a frequency domain Low Pass Butterworth Filter with cutoff pe-riod tc and order n . At the cutoff period the filter amplitude is about 0.7 of the amplitude atH(0,0). This function returns the mask filter with H(0,0). As the larger the filter order, sharperwill be the amplitude transition at cutoff period. The minimum cutoff period is always 2 pixels,despite of the size of the frequency filter.

Examples:>>> H2_10 = iabwlp([100,100],2,10) # cutoff period: 2 pixels, order: 10

>>> iashow(iadftview(H2_10))

>>> H4_1 = iabwlp([100,100],4,1) # cutoff period: 4, order: 1


>>> H8_100 = iabwlp([100,100],8,100) # cutoff period: 8, order: 100


>>> H4_1box = iabwlp([100,100],4,1,’square’) # cutoff period: 4, order: 1

>>> iashow(iadftview(H4_1box))

83

84 APENDICE C. FUNCTIONS

(iadftview(H2_10)) (iadftview(H4_1)) (iadftview(H8_100)) (iadftview(H4_1box))

>>> import Numeric

>>> import FFT

>>> f = iaread(’cookies.pgm’)

>>> iashow(f)

>>> F = FFT.fft2d(f)

>>> iashow(iadftview(F))

>>> H = iabwlp(F.shape,16,6)

>>> iashow(iadftview(H))

>>> G = F * H

>>> iashow(iadftview(G))

>>> g = FFT.inverse_fft2d(G)

>>> g = abs(g).astype(Numeric.UnsignedInt8)

>>> iashow(g)

(f) (iadftview(F)) (iadftview(H)) (iadftview(G))

(g)

Equation:

H(u, v) =1

1 + (√

2− 1)(√

( uN

)2 + ( vM

)2 tc)2n

(u, v) ∈ {−bN2c : N − bN

2c − 1,−bM

2c : M − bM

2c − 1}

tc ∈ {2 : max{N, M}}

C.1.2 iacirclePurpose: Create a binary circle image.

Synopsis: g = iacircle(s, r, c)

Input:s <type ’array’> [rows cols], output image dimensions.r <type ’float’> radius.c <type ’array’> [row0 col0], center of the circle.

Output:g <type ’array’>

Description: Creates a binary image with dimensions given by s, radius given by r and center given byc. The pixels inside the circle are one and outside zero.

C.1. IMAGE CREATION 85

Examples:>>> F = iacircle([5,7], 2, [2,3])

>>> print F

[[0 0 0 1 0 0 0]

[0 0 1 1 1 0 0]

[0 1 1 1 1 1 0]

[0 0 1 1 1 0 0]

[0 0 0 1 0 0 0]]

>>> F = iacircle([200,300], 90, [100,150])

>>> iashow(F)

(F)

Equation:

g(x, y) = (x− xc)2 + (y − yc)

2 ≤ r2

See also: iarectangle (C.1.8)

C.1.3 iacombPurpose: Create a grid of impulses image.

Synopsis: g = iacomb(s, delta, offset)

Input:s <type ’array’> output image dimensions (1-D, 2-D or 3-D).

delta <type ’array’> interval between the impulses in each dimension (1-D, 2-Dor 3-D).

offset <type ’array’> offset in each dimension (1-D, 2-D or 3-D).


Examples:>>> u1 = iacomb(10, 3, 2)

>>> print u1

[0 0 1 0 0 1 0 0 1 0]

>>> u2 = iacomb((7,9), (3,4), (3,2))

>>> print u2

[[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 1 0 0 0 1 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 1 0 0 0 1 0 0]]

>>> u3 = iacomb((7,9,4), (3,4,2), (2,2,1))

>>> print u3[:,:,0]

[[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]


[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]]

>>> print u3[:,:,1]

[[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 1 0 0 0 1 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 1 0 0 0 1 0 0]

[0 0 0 0 0 0 0 0 0]]

>>> print u3[:,:,2]

[[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]]

>>> print u3[:,:,3]

[[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 1 0 0 0 1 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 1 0 0 0 1 0 0]

[0 0 0 0 0 0 0 0 0]]

Equation:

u(x) =

N−1∑

i=0

δ (x− (ki + o))

x ∈ [0, D − 1]

u (x1, x2, · · · , xn) =

N1−1∑

i1=0

N2−1∑

i2=0

· · ·Nn−1∑

in=0

δ (x1 − (k1i1 + o1) , x2 − (k2i2 + o2) , · · · , xn − (knin + on))

(x1, x2, · · · , xn) ∈ [(0, 0, · · · , 0) , (D1 − 1, D2 − 1, · · · , D3 − 1)]

where δ(i) =

{

1, i = 00, otherwise

See also: iaptrans (C.6.3)

C.1.4 iacosPurpose: Create a cossenoidal image.

Synopsis: f = iacos(s, t, theta, phi)


Input:s <type ’array’> size: [rows cols].t <type ’array’> Period: in pixels.

theta <type ’float’> spatial direction of the wave, in radians. 0 is a wave on thehorizontal direction.

phi <type ’float’> Phase

Output:f <type ’array’>

Description: Generate a cosenosoid image of size s with amplitude 1, period T, phase phi and wavedirection of theta. The output image is a double array.

Examples:>>> import Numeric

>>> f = iacos([128,256], 100, Numeric.pi/4, 0)

>>> iashow(ianormalize(f, [0,255]))

(ianormalize(f, [0,255]))

Equation:

f(x, y) = sin(2π(fxx + fyy) + φ)

fx =cos(θ)

T

fy =sin(θ)

T

C.1.5 iagaussianPurpose: Generate a 2D Gaussian image.

Synopsis: g = iagaussian(s, mu, sigma)

Input:s <type ’array’> [rows columns]

mu <type ’array’> Mean vector. 2D point (x;y). Point of maximum value.sigma <type ’array’> covariance matrix (square). [ Sxˆ2 Sxy; Syx Syˆ2]


Description: A 2D Gaussian image is an image with a Gaussian distribution. It can be used to gene-rate test patterns or Gaussian filters both for spatial and frequency domain. The integral of thegaussian function is 1.0.


>>> f = iagaussian([8,4], [3,1], [[1,0],[0,1]])

>>> print Numeric.array2string(f, precision=4, suppress_small=1)

[[ 0.0011 0.0018 0.0011 0.0002]

[ 0.0131 0.0215 0.0131 0.0029]

[ 0.0585 0.0965 0.0585 0.0131]


[ 0.0965 0.1592 0.0965 0.0215]

[ 0.0585 0.0965 0.0585 0.0131]

[ 0.0131 0.0215 0.0131 0.0029]

[ 0.0011 0.0018 0.0011 0.0002]

[ 0. 0.0001 0. 0. ]]

>>> g = ianormalize(f, [0,255]).astype(Numeric.UnsignedInt8)

>>> print g

[[ 1 2 1 0]

[ 20 34 20 4]

[ 93 154 93 20]

[154 255 154 34]

[ 93 154 93 20]

[ 20 34 20 4]

[ 1 2 1 0]

[ 0 0 0 0]]

>>> f = iagaussian(100, 50, 10*10)

>>> g = ianormalize(f, [0,1])

>>> g,d = iaplot(g)

0

0.2

0.4

0.6

0.8

1

0 10 20 30 40 50 60 70 80 90 100

(g)

>>> f = iagaussian([50,50], [25,10], [[10*10,0],[0,20*20]])

>>> g = ianormalize(f, [0,255]).astype(Numeric.UnsignedInt8)

>>> iashow(g)

(g)

Equation:

f(x) =1√2πσ

exp

[

−1

2

(

x− µ

σ

)2]

f(x) =1

(2π)d/2|Σ|1/2exp

[

−1

2(x− µ)t Σ−1 (x− µ)

]

See also: iacircle (C.1.2)

C.1.6 ialogPurpose: Laplacian of Gaussian image.

Synopsis: g = ialog(s, mu, sigma)


Input:s <type ’array’> [rows cols], output image dimensions.

mu <type ’array’> [row0 col0], center of the function.sigma <type ’float’> spread factor.


Description: Creates a Laplacian of Gaussian image with dimensions given by s, origin given by c andspreading factor given by sigma. This function is used in the Marr-Hildreth filter.

Examples:>>> F = ialog([5,7], [3,4], 1)

>>> print Numeric.array2string(F, precision=4, suppress_small=1)

[[-0. -0.0006 -0.0053 -0.0172 -0.0248 -0.0172 -0.0053]

[-0.0003 -0.0053 -0.035 -0.0784 -0.0862 -0.0784 -0.035 ]

[-0.001 -0.0172 -0.0784 -0. 0.1931 -0. -0.0784]

[-0.0015 -0.0248 -0.0862 0.1931 0.6366 0.1931 -0.0862]

[-0.001 -0.0172 -0.0784 -0. 0.1931 -0. -0.0784]]

>>> h = ialog([200,300], [100,150], 20)

>>> iashow(h)

>>> g,d = iaplot(h[100,:])

(h) -0.0004

-0.0002

0

0.0002

0.0004

0.0006

0.0008

0.001

0.0012

0.0014

0.0016

0 50 100 150 200 250 300

(h[100,:])

C.1.7 iarampPurpose: Create an image with vertical bands of increasing gray values.

Synopsis: g = iaramp(s, n, range)

Input:s <type ’array’> [H W], height and width output image dimensions.n <type ’float’> number of vertical bands.

range <type ’array’> [kmin, kmax], minimum and maximum gray scale values.


Description: Creates a gray scale image with dimensions given by s, with n increasing gray scale bandsfrom left to right with values varying from the specified range.

Examples:>>> F = iaramp([5,7], 3, [4,10])

>>> print F

[[ 4 4 4 7 7 10 10]

[ 4 4 4 7 7 10 10]

[ 4 4 4 7 7 10 10]

[ 4 4 4 7 7 10 10]

[ 4 4 4 7 7 10 10]]


>>> F = iaramp([200,300], 10, [0,255])

>>> iashow(F)

(F)

Equation:

g(x, y) = bb n

Wxckmax − kmin

n− 1c+ kmin


C.1.8 iarectanglePurpose: Create a binary rectangle image.

Synopsis: g = iarectangle(s, r, c)

Input:s <type ’array’> [rows cols], output image dimensions.r <type ’float’> [rrows ccols], rectangle image dimensions.c <type ’array’> [row0 col0], center of the rectangle.


Description: Creates a binary image with dimensions given by s, rectangle dimensions given by r andcenter given by c. The pixels inside the rectangle are one and outside zero.

Examples:>>> F = iarectangle([7,9], [3,2], [3,4])

>>> print F

[[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 1 1 0 0 0 0]

[0 0 0 1 1 0 0 0 0]

[0 0 0 1 1 0 0 0 0]

[0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]]

>>> F = iarectangle([200,300], [90,120], [70,120])

>>> iashow(F)

(F)

Equation:

g(x, y) =

{

1, xmin ≤ x < xmax and ymin ≤ y < ymax

0, otherwise


C.2. IMAGE INFORMATION AND MANIPULATION 91

C.2 Image Information and Manipulation

C.2.1 iacropPurpose: Crop an image to find the minimum rectangle.

Synopsis: g = iacrop(f, side=’all’, color=’black’)

Input:f <type ’array’> input image.

side <type ’str’> side of the edge which will be removed. Possible values: ’all’,’left’, ’right’, ’top’, ’bottom’.

color <type ’str’> color of the edge. Possible values: ’black’, ’white’.


Examples:>>> f = iaread(’club.pgm’)

>>> iashow(f)

>>> g = iacrop(f)

>>> iashow(g)

(f) (g)

See also: iapad (C.2.6)

C.2.2 iaind2subPurpose: Convert linear index to double subscripts.

Synopsis: x, y = iaind2sub(dim, i)

Input:dim <type ’array’> Dimension.

i <type ’array’> Index.

Output:x <type ’array’>y <type ’array’>

Examples:>>> f = Numeric.array([[0,6,0,2],[4,0,1,8],[0,0,3,0]])

>>> print f

[[0 6 0 2]

[4 0 1 8]

[0 0 3 0]]

>>> i = Numeric.nonzero(Numeric.ravel(f))

>>> (x,y) = iaind2sub(f.shape, i)

>>> print x


[0 0 1 1 1 2]

>>> print y

[1 3 0 2 3 2]

>>> print f[x[0],y[0]]

6

>>> print f[x[4],y[4]]

8

C.2.3 iameshgridPurpose: Create two 2-D matrices of indexes.

Synopsis: x, y = iameshgrid(vx, vy)

Input:vx <type ’array’> Vector of indices of x coordinate.vy <type ’array’> Vector of indices of y coordinate.

Output:x <type ’array’> 2-D matrix of indexes of x coordinate.y <type ’array’> 2-D matrix of indexes of y coordinate.

Description: This function generates 2-D matrices of indices of the domain specified by arange1 andarange2. This is very useful to generate 2-D functions. Note that unlike other functions, theorder of the parameters uses the cartesian coordenate convention. arange1 is for x (horizontal),and arange2 is for y (vertical).

Examples:>>> (x, y) = iameshgrid(Numeric.arange(1,3,0.5), Numeric.arange(2,4,0.6))

>>> print x

[[ 1. 1.5 2. 2.5]

[ 1. 1.5 2. 2.5]

[ 1. 1.5 2. 2.5]

[ 1. 1.5 2. 2.5]]

>>> print y

[[ 2. 2. 2. 2. ]

[ 2.6 2.6 2.6 2.6]

[ 3.2 3.2 3.2 3.2]

[ 3.8 3.8 3.8 3.8]]

>>> print x + y

[[ 3. 3.5 4. 4.5]

[ 3.6 4.1 4.6 5.1]

[ 4.2 4.7 5.2 5.7]

[ 4.8 5.3 5.8 6.3]]

>>> (x, y) = iameshgrid(range(256), range(256))

>>> iashow(x)

>>> iashow(y)

>>> iashow(x + y)

>>> z = Numeric.sqrt((x-127)**2 + (y-127)**2)

>>> iashow(z)

(x) (y) (x + y) (z)


Equation:

vx(j), j = 0, 1, . . . n

vy(i), i = 0, 1, . . . m

x(i, j) = vx(i)

y(i, j) = vy(j)

C.2.4 ianegPurpose: Negate an image.

Synopsis: g = ianeg(f)

Input:f <type ’array’> Set initial.


Description: Returns an image that is the negation (i.e., inverse or involution) of the input image.

Examples:>>> c1 = Numeric.array([0, 53, 150, 255], Numeric.UnsignedInt8)

>>> print c1

[ 0 53 150 255]

>>> n1 = ianeg(c1)

>>> print n1

[255 202 105 0]

>>> c2 = Numeric.array([-129, -128, 0, 127, 128], Numeric.Int8)

>>> print c2

[ 127 -128 0 127 -128]

>>> n2 = ianeg(c2)

>>> print n2

[-127. 128. -0. -127. 128.]

Equation:

ν(f)(x) = k − f(x)

C.2.5 ianormalizePurpose: Normalize the pixels values between the specified range.

Synopsis: g = ianormalize(f, range)


range <type ’array’> vector: minimum and maximum values in the output image,respectively.

Output:g <type ’array’> normalized image.


Description: Normalize the input image f. The minimum value of f is assigned to the minimum desiredvalue and the maximum value of f, to the maximum desired value. The minimum and maximumdesired values are given by the parameter range.


>>> f = Numeric.array([100., 500., 1000.])

>>> g1 = ianormalize(f, [0,255])

>>> print g1

[ 0. 113.33333333 255. ]

>>> g2 = ianormalize(f, [-1,1])

>>> print g2

[-1. -0.11111111 1. ]


>>> print g3

[ 0. 0.44444444 1. ]

>>> #

>>> f = Numeric.array([-100., 0., 100.])


>>> print g4

[ 0. 127.5 255. ]

>>> g5 = ianormalize(f, [-1,1])

>>> print g5

[-1. 0. 1.]

Equation:

g = f |gmaxgmin

g(p) =gmax − gmin

fmax − fmin(f(p)− fmin) + gmin

C.2.6 iapadPurpose: Extend the image inserting a frame around it.

Synopsis: g = iapad(f, thick=[1,1], value=0)


thick <type ’array’> [rows cols] to be padded.value <type ’float’> value used in the frame around the image.


Examples:>>> f = Numeric.array([[0,1,2],[3,4,5]], Numeric.UnsignedInt8)

>>> print f

[[0 1 2]

[3 4 5]]

>>> g1 = iapad(f)

>>> print g1

[[0 0 0 0 0]

[0 0 1 2 0]

[0 3 4 5 0]

[0 0 0 0 0]]


>>> g2 = iapad(f, (1,3), 5)

>>> print g2

[[5 5 5 5 5 5 5 5 5]

[5 5 5 0 1 2 5 5 5]

[5 5 5 3 4 5 5 5 5]

[5 5 5 5 5 5 5 5 5]]

See also: iacrop (C.2.1)

C.2.7 iaroiPurpose: Cut a rectangle out of an image.

Synopsis: g = iaroi(f, p1, p2)


p1 <type ’array’> indices of the coordinates at top-left.p2 <type ’array’> indices of the coordinates at bottom-right.


Examples:>>> f = iaread(’lenina.pgm’)

>>> iashow(f)

>>> froi = iaroi(f, [90,70], [200,180])

>>> iashow(froi)

(f) (froi)

C.2.8 iasub2indPurpose: Convert linear double subscripts to linear index.

Synopsis: i = iasub2ind(dim, x, y)

Input:dim <type ’array’> Dimension.

x <type ’array’> x index.y <type ’array’> y index.

Output:i <type ’array’>

Examples:>>> f = Numeric.array([[0,6,0,2],[4,0,1,8],[0,0,3,0]])

>>> print f

[[0 6 0 2]

[4 0 1 8]


[0 0 3 0]]

>>> x=[0,0,1,2,2,2]

>>> y=[0,2,1,0,1,3]

>>> print x

[0, 0, 1, 2, 2, 2]

>>> print y

[0, 2, 1, 0, 1, 3]

>>> i = iasub2ind(f.shape, x, y)

>>> print i

[ 0 2 5 8 9 11]

>>> Numeric.put(f, i, 10)

>>> print f

[[10 6 10 2]

[ 4 10 1 8]

[10 10 3 10]]

C.2.9 iatilePurpose: Replicate the image until reach a new size.

Synopsis: g = iatile(f, new_size)


new size <type ’array’> [rows cols], output image dimensions.


Examples:>>> f=[[1,2],[3,4]]

>>> print f

[[1, 2], [3, 4]]

>>> g = iatile(f, (3,6))

>>> print g

[[1 2 1 2 1 2]

[3 4 3 4 3 4]

[1 2 1 2 1 2]]

C.3 Image file I/O

C.3.1 iareadPurpose: Read an image file (PBM, PGM and PPM).

Synopsis: img = iaread(filename)

Input:filename <type ’str’>

Output:img <type ’array’>

C.4. CONTRAST MANIPULATION 97

Examples:>>> f = iaread(’boat.ppm’)

>>> iashow(f)

(f)

See also: iawrite (C.3.2)

C.3.2 iawritePurpose: Write an image file (PBM, PGM and PPM).

Synopsis: iawrite(arrayname, filename, mode=’bin’)

Input:arrayname <type ’array’>filename <type ’str’>

mode <type ’str’>

Examples:>>> f = Numeric.resize(range(256), (256, 256))

>>> f_color = Numeric.zeros((256, 256, 3))

>>> f_color[:,:,0] = f; f_color[:,:,1] = 127; f_color[:,:,2] = 255-f

>>> import tempfile

>>> file_name = tempfile.mktemp() # Name for a temporary file

>>> print file_name

/tmp/@1647.2

>>> print ’Saving f in ’+file_name+’.pgm ...’

Saving f in /tmp/@1647.2.pgm ...

>>> iawrite(f, file_name+’.pgm’)

>>> print ’Saving f_color in ’+file_name+’.ppm ...’

Saving f color in /tmp/@1647.2.ppm ...

>>> iawrite(f_color, file_name+’.ppm’)

C.4 Contrast Manipulation

C.4.1 iaapplylutPurpose: Intensity image transform.

Synopsis: g = iaapplylut(fi, it)

Input:fi <type ’array’> input image, gray scale or index image.it <type ’array’> Intensity transform. Table of one or three columns.



Description: Apply an intensity image transform to the input image. The input image can be seen asan gray scale image or an index image. The intensity transform is represented by a table wherethe input (gray scale) color address the table line and its column contents indicates the output(gray scale) image color. The table can have one or three columns. If it has three columns, theoutput image is a three color band image. This intensity image transformation is very powerfuland can be use in many applications involving gray scale and color images. If the input image hasan index (gray scale color) that is greater than the size of the intensity table, an error is reported.

Examples:>>> f = [[0,1,2], [3,4,5]]

>>> it = Numeric.array(range(6)) # identity transform

>>> print it

[0 1 2 3 4 5]

>>> g = iaapplylut(f, it)

>>> print g

[[0 1 2]

[3 4 5]]

>>> itn = 5 - it # negation

>>> g = iaapplylut(f, itn)

>>> print g

[[5 4 3]

[2 1 0]]

>>> f = iaread(’cameraman.pgm’)

>>> it = 255 - Numeric.arange(256)


>>> iashow(f)

>>> iashow(g)

(f) (g)

>>> f = [[0,1,1], [0,0,1]]

>>> ct = [[255,0,0], [0,255,0]]

>>> g = iaapplylut(f,ct)

>>> print g

[[[255 0 0]

[ 0 255 0]

[ 0 255 0]]

[[255 0 0]

[255 0 0]

[ 0 255 0]]]


>>> aux = Numeric.resize(range(256), (256,1))

>>> ct = Numeric.concatenate((aux, Numeric.zeros((256,2))), 1)

>>> g = iaapplylut(f, ct)

>>> iashow(f)

>>> iashow(g)

(f) (g)

C.5. COLOR PROCESSING 99

Equation:

g(x, y) = IT (f(x, y))

gr(x, y) = IT (f(x, y), 0)

gg(x, y) = IT (f(x, y), 1)

gb(x, y) = IT (f(x, y), 2)

C.4.2 iacolormapPurpose: Create a colormap table.

Synopsis: ct = iacolormap(type=’gray’)

Input:type <type ’str’> Type of the colormap. Options: ’gray’, ’hsv’, ’hot’, ’cool’,

’bone’,’copper’, ’pink’.

Output:ct <type ’array’> Colormap table.

Description: Create a colormap table.

Examples:>>> f = ianormalize(iabwlp([150,150], 4, 1), [0,255]).astype(’b’)

>>> cm1 = iacolormap(’hsv’)

>>> g_cm1 = iaapplylut(f, cm1)

>>> cm2 = iacolormap(’hot’)

>>> g_cm2 = iaapplylut(f, cm2)

>>> iashow(f)

>>> iashow(g_cm1)

>>> iashow(g_cm2)

(f) (g_cm1) (g_cm2)

C.5 Color Processing

C.5.1 iahsv2rgbPurpose: Convert HSV to RGB color model.

Synopsis: g = iahsv2rgb(f)

Input:f <type ’array’> HSV color model.


Output:g <type ’array’> True color RGB image.

Description: Converts hue-saturation-value to red-green-blue colors.


>>> r = [[4,5,6],[4,2,4]]

>>> g = [[0,1,2],[0,4,0]]

>>> b = [[1,0,2],[1,2,2]]

>>> f = Numeric.zeros((2,3,3))

>>> f[:,:,0], f[:,:,1], f[:,:,2] = r, g, b

>>> print f[:,:,0]

[[4 5 6]

[4 2 4]]

>>> print f[:,:,1]

[[0 1 2]

[0 4 0]]

>>> print f[:,:,2]

[[1 0 2]

[1 2 2]]

>>> g = iargb2hsv(f)

>>> f_ = iahsv2rgb(g)

>>> print f_[:,:,0]

[[ 4. 5. 6.]

[ 4. 2. 4.]]

>>> print f_[:,:,1]

[[ 0. 1. 2.]

[ 0. 4. 0.]]

>>> print f_[:,:,2]

[[ 1. 0. 2.]

[ 1. 2. 2.]]

C.5.2 iargb2hsvPurpose: Convert RGB to HSV color model.

Synopsis: g = iargb2hsv(f)

Input:f <type ’array’> True color RGB image.

Output:g <type ’array’> HSV color model.

Description: Converts red-green-blue colors to hue-saturation-value.


>>> r = [[4,5,6],[4,2,4]]

>>> g = [[0,1,2],[0,4,0]]

>>> b = [[1,0,2],[1,2,2]]


>>> f[:,:,0], f[:,:,1], f[:,:,2] = r, g, b

>>> print f[:,:,0]

[[4 5 6]

C.5. COLOR PROCESSING 101

[4 2 4]]

>>> print f[:,:,1]

[[0 1 2]

[0 4 0]]

>>> print f[:,:,2]

[[1 0 2]

[1 2 2]]

>>> g = iargb2hsv(f)

>>> print g[:,:,0]

[[ 0.95833333 0.03333333 0. ]

[ 0.95833333 0.33333333 0.91666667]]

>>> print g[:,:,1]

[[ 1. 1. 0.66666667]

[ 1. 0.5 1. ]]

>>> print g[:,:,2]

[[ 0.01568627 0.01960784 0.02352941]

[ 0.01568627 0.01568627 0.01568627]]

C.5.3 iargb2ycbcrPurpose: Convert RGB to YCbCr color model.

Synopsis: g = iargb2ycbcr(f)


Output:g <type ’array’> YCbCr image.

Description: Convert RGB values to YCbCr color space.


>>> r = [[4,5,6],[4,2,4]]

>>> g = [[0,1,2],[0,4,0]]

>>> b = [[1,0,2],[1,2,2]]


>>> f[:,:,0], f[:,:,1], f[:,:,2] = r, g, b

>>> print f[:,:,0]

[[4 5 6]

[4 2 4]]

>>> print f[:,:,1]

[[0 1 2]

[0 4 0]]

>>> print f[:,:,2]

[[1 0 2]

[1 2 2]]

>>> g = iargb2ycbcr(f)

>>> print g[:,:,0]

[[ 17.126 17.789 18.746]

[ 17.126 18.726 17.224]]

>>> print g[:,:,1]

[[ 127.847 126.969 127.408]

[ 127.847 127.418 128.286]]

>>> print g[:,:,2]

[[ 129.685 129.827 129.756]

[ 129.685 127.264 129.614]]


C.5.4 iatcrgb2indPurpose: True color RGB to index image and colormap.

Synopsis: fi,cm = iatcrgb2ind(f)


Output:fi,cm <type ’array’> Index image and its colormap.

Description: Converts a true color RGB image to the format of index image and a colormap.


>>> r = [[4,5,6],[4,2,4]]

>>> g = [[0,1,2],[0,4,0]]

>>> b = [[1,0,2],[1,2,2]]


>>> f[:,:,0], f[:,:,1], f[:,:,2] = r, g, b

>>> print f

[[[4 0 1]

[5 1 0]

[6 2 2]]

[[4 0 1]

[2 4 2]

[4 0 2]]]

>>> (fi, tm) = iatcrgb2ind(f)

>>> print fi

[[1 0 3]

[1 4 2]]

>>> print tm

[[5 1 0]

[4 0 1]

[4 0 2]

[6 2 2]

[2 4 2]]

C.5.5 iaycbcr2rgbPurpose: Convert RGB to YCbCr color model.

Synopsis: g = iaycbcr2rgb(f)

Input:f <type ’array’> YCbCr image.

Output:g <type ’array’> True color RGB image.

Description: Convert RGB values to YCbCr color space.

C.6. GEOMETRIC MANIPULATIONS 103


>>> r = [[4,5,6],[4,2,4]]

>>> g = [[0,1,2],[0,4,0]]

>>> b = [[1,0,2],[1,2,2]]


>>> f[:,:,0], f[:,:,1], f[:,:,2] = r, g, b

>>> print f[:,:,0]

[[4 5 6]

[4 2 4]]

>>> print f[:,:,1]

[[0 1 2]

[0 4 0]]

>>> print f[:,:,2]

[[1 0 2]

[1 2 2]]

>>> g = iargb2ycbcr(f)

>>> f_ = iaycbcr2rgb(g)

>>> print f_[:,:,0]

[[ 3.999924 4.998288 5.99892 ]

[ 3.999924 1.998408 4.00068 ]]

>>> print f_[:,:,1]

[[ 7.35000000e-04 1.00119700e+00 2.00078000e+00]

[ 7.35000000e-04 3.99957600e+00 4.42000000e-04]]

>>> print f_[:,:,2]

[[ 1.002063 0.002869 2.00228 ]

[ 1.002063 1.99917 2.001598]]

C.6 Geometric Manipulations

C.6.1 iaffinePurpose: Affine transform.

Synopsis: g = iaffine(f, T)

Input:f <type ’array’>T <type ’array’> Affine matrix for the geometric transformation.


Description: Apply the affine transform to the coordinate pixels of image f. The resultant image ghas the same domain of the input image. Any pixel outside this domain is not shown and anypixel that does not exist in the original image has the nearest pixel value. This method is basedon the inverse mapping. An affine transform is a geometrical transformation that preserves theparallelism of lines but not their lengths and angles. The affine transform can be a composition oftranslation, rotation, scaling and shearing. To simplify this composition, these transformationsare represented in homogeneous coordinates using 3x3 matrix T.

Examples:>>> f = Numeric.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])

>>> print f

[[ 1 2 3 4 5]


[ 6 7 8 9 10]

[11 12 13 14 15]]

>>> T = Numeric.array([[1,0,0],[0,1,0],[0,0,1]], ’d’)

>>> print T

[[ 1. 0. 0.]

[ 0. 1. 0.]

[ 0. 0. 1.]]

>>> g = iaffine(f,T)

>>> print g

[[ 1 2 3 4 5]

[ 6 7 8 9 10]

[11 12 13 14 15]]

>>> T[0,0] = 0.5

>>> print T

[[ 0.5 0. 0. ]

[ 0. 1. 0. ]

[ 0. 0. 1. ]]

>>> g = iaffine(f,T)

>>> print g

[[ 2 4 5 5 5]

[ 7 9 10 10 10]

[12 14 15 15 15]]

Equation:

T =

t1,1 t1,2 t1,3

t2,1 t2,2 t2,3

0 0 1

x′

y′

1

= T

xy1

g(x, y) = f(T−1(x, y)); (x, y) ∈ D(f)

See also: iageorigid (C.6.2)

C.6.2 iageorigidPurpose: 2D Rigid body geometric transformation and scaling.

Synopsis: g = iageorigid(f, scale, theta, t)

Input:f <type ’array’>

scale <type ’array’> [srow scol], scale in each dimensiontheta <type ’float’> Rotation

t <type ’array’> [trow tcol], translation in each dimension



>>> f = iaread(’lenina.pgm’)

>>> g = iageorigid(f, [0.5,0.5], Numeric.pi/4, [0,64])

C.6. GEOMETRIC MANIPULATIONS 105

>>> iashow(g)

(g)

Equation:

Tθ =

cos(θ) sin(θ) 0−sin(θ) cos(θ) 0

0 0 1

Ts =

Sx 0 00 Sy 00 0 1

Tt =

0 0 tx0 0 ty0 0 1

T = TtTθTs

g(x, y) = f(T−1(x, y)); (x, y) ∈ D(f)

See also: iaffine (C.6.1)

C.6.3 iaptransPurpose: Periodic translation.

Synopsis: g = iaptrans(f, t)

Input:f <type ’array’>t <type ’array’> [rows cols] to translate.


Description: Translate the image periodically by t=[r0 c0]. This translation can be seen as a windowview displacement on an infinite tile wall where each tile is a copy of the original image. Theperiodical translation is related to the periodic convolution and discrete Fourier transform. Becareful when implementing this function using the mod, some mod implementations in C does notfollow the correct definition when the number is negative.


>>> f = Numeric.array([[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15]])

>>> print f

[[ 1 2 3 4 5]

[ 6 7 8 9 10]

[11 12 13 14 15]]

>>> print iaptrans(f, [-1,2]).astype(Numeric.UnsignedInt8)

[[ 9 10 6 7 8]


[14 15 11 12 13]

[ 4 5 1 2 3]]

>>> import Numeric


>>> iashow(f)

>>> iashow(iaptrans(f, Numeric.array(f.shape)/2))

(f) (iaptrans(f, Numeric.array(f.shape)/2))

Equation:

t = (txty)

g = ft = ftx,ty

g(x, y) = f((x− tx) mod W, (y − ty) mod H), 0 ≤ x < W, 0 ≤ y < H

where

a mod N = (a + kN) mod N, k ∈ Z

See also: iapconv (C.8.4)

C.6.4 iaresizePurpose: Resizes an image.

Synopsis: g = iaresize(f, new_shape)


new shape <type ’array’> [h w], new image dimensions



>>> f = Numeric.array([[10,20,30],[40,50,60]])

>>> print f

[[10 20 30]

[40 50 60]]

>>> g = iaresize(f, [5,7])

>>> print g

[[10 10 10 20 20 30 30]

[10 10 10 20 20 30 30]

[10 10 10 20 20 30 30]

[40 40 40 50 50 60 60]

[40 40 40 50 50 60 60]]

C.7. IMAGE TRANSFORMATION 107

C.7 Image Transformation

C.7.1 iadctPurpose: Discrete Cossine Transform.

Synopsis: F = iadct(f)


Output:F <type ’array’>


>>> f = 255 * iacircle([256,256], 10, [129,129])

>>> iashow(f)

>>> F = iadct(f)

>>> iashow(Numeric.log(abs(F)+1))

(f) (Numeric.log(abs(F)+1))

C.7.2 iadctmatrixPurpose: Kernel matrix for the DCT Transform.

Synopsis: A = iadctmatrix(N)

Input:N <type ’float’>

Output:A <type ’array’>

Examples:>>> A = iadctmatrix(128)

>>> iashow(A)

(A)

>>> import Numeric

>>> A = iadctmatrix(4)

>>> print Numeric.array2string(A, precision=4, suppress_small=1)

[[ 0.5 0.5 0.5 0.5 ]

[ 0.6533 0.2706 -0.2706 -0.6533]


[ 0.5 -0.5 -0.5 0.5 ]

[ 0.2706 -0.6533 0.6533 -0.2706]]

>>> B = Numeric.matrixmultiply(A,Numeric.transpose(A))

>>> print Numeric.array2string(B, precision=4, suppress_small=1)

[[ 1. 0. -0. -0.]

[ 0. 1. 0. 0.]

[-0. 0. 1. 0.]

[-0. 0. 0. 1.]]

C.7.3 iadftPurpose: Discrete Fourier Transform.

Synopsis: F = iadft(f)



Examples:>>> f = 255 * iacircle([256,256], 10, [129,129])

>>> iashow(f)

>>> F = iadft(f)

>>> Fv = iadftview(F)

>>> iashow(Fv)

(f) (Fv)

Equation:

F (u) =

N−1∑

x=0

f(x) exp(−j2πux

N)

0 ≤ x < N, 0 ≤ u < N

F =√

NANf

F (u, v) =

N−1∑

x=0

M−1∑

y=0

f(x, y) exp(−j2π(ux

N+

vy

M))

(0, 0) ≤ (x, y) < (N, M), (0, 0) ≤ (u, v) < (N, M)

F =√

NMANfAM

See also: iaidft (C.7.11), iadftmatrix (C.7.4), iadftview (C.12.1), iaisdftsym (C.7.15)


C.7.4 iadftmatrixPurpose: Kernel matrix for the DFT Transform.

Synopsis: A = iadftmatrix(N)




>>> A = iadftmatrix(128)

>>> iashow(A.imag)

>>> iashow(A.real)

(A.imag) (A.real)

>>> import Numeric

>>> import LinearAlgebra


>>> print Numeric.array2string(A, precision=4, suppress_small=1)

[[ 0.5+0.j 0.5+0.j 0.5+0.j 0.5+0.j ]

[ 0.5+0.j 0. -0.5j -0.5-0.j -0. +0.5j]

[ 0.5+0.j -0.5-0.j 0.5+0.j -0.5-0.j ]

[ 0.5+0.j -0. +0.5j -0.5-0.j 0. -0.5j]]

>>> print Numeric.array2string(A-Numeric.transpose(A), precision=4, suppress_small=1)←↩

[[ 0.+0.j 0.+0.j 0.+0.j 0.+0.j]

[ 0.+0.j 0.+0.j 0.+0.j 0.+0.j]

[ 0.+0.j 0.+0.j 0.+0.j 0.+0.j]

[ 0.+0.j 0.+0.j 0.+0.j 0.+0.j]]

>>> print abs(LinearAlgebra.inverse(A)-Numeric.conjugate(A)) < 10E-15

[[1 1 1 1]

[1 1 1 1]

[1 1 1 1]

[1 1 1 1]]

Equation:

WN = exp−j2π

N

AN =1√N

(WN )uxT

u = x = [0, 1, 2, . . . , N − 1]T

AN = ATN symmetric

(AN )−1 = (AN )∗ column orthogonality, unitary matrix


See also: iadft (C.7.3), iaidft (C.7.11)

C.7.5 iafftshiftPurpose: Shifts zero-frequency component to center of spectrum.

Synopsis: HS = iafftshift(H)

Input:H <type ’array’> FFT image.

Output:HS <type ’array’> Shift of the FFT image.

Description: The origen (0,0) of the DFT is normally at top-left corner of the image. For visualizationpurposes, it is common to periodicaly translate the origen to the image center. This is particularlyinteresting because of the complex conjugate simmetry of the DFT of a real function. Note thatas the image can have even or odd sizes, to translate back the DFT from the center to the corner,there is another correspondent function.


>>> import FFT

>>> f = iarectangle([120,150],[7,10],[60,75])


>>> Fs = iafftshift(F)


>>> iashow(Numeric.log(abs(Fs)+1))

(Numeric.log(abs(F)+1)) (Numeric.log(abs(Fs)+1))

Equation:

HS = Hxo,yo

xo = bW/2cyo = bH/2c

See also: iaifftshift (C.7.12), iaptrans (C.6.3), iadftview (C.12.1)

C.7.6 iahaarmatrixPurpose: Kernel matrix for the Haar Transform.

Synopsis: A = iahaarmatrix(N)




Examples:>>> A = iahaarmatrix(128)

>>> iashow(A)

(A)

>>> import Numeric

>>> A = iahaarmatrix(4)

>>> print A

[[ 0.5 0.5 0.5 0.5 ]

[ 0.5 0.5 -0.5 -0.5 ]

[ 0.70710678 -0.70710678 0. 0. ]

[ 0. 0. 0.70710678 -0.70710678]]

>>> print Numeric.matrixmultiply(A, Numeric.transpose(A))

[[ 1. 0. 0. 0.]

[ 0. 1. 0. 0.]

[ 0. 0. 1. 0.]

[ 0. 0. 0. 1.]]

C.7.7 iahadamardPurpose: Hadamard Transform.

Synopsis: F = iahadamard(f)





>>> iashow(f)

>>> F = iahadamard(f)



C.7.8 iahadamardmatrixPurpose: Kernel matrix for the Hadamard Transform.

Synopsis: A = iahadamardmatrix(N)




Examples:>>> A = iahadamardmatrix(128)

>>> iashow(A)

(A)

>>> import Numeric

>>> A = iahadamardmatrix(4)

>>> print A

[[ 0.5 0.5 0.5 0.5]

[ 0.5 -0.5 0.5 -0.5]

[ 0.5 0.5 -0.5 -0.5]

[ 0.5 -0.5 -0.5 0.5]]

>>> print Numeric.matrixmultiply(A, Numeric.transpose(A))

[[ 1. 0. 0. 0.]

[ 0. 1. 0. 0.]

[ 0. 0. 1. 0.]

[ 0. 0. 0. 1.]]

C.7.9 iahwtPurpose: Haar Wavelet Transform.

Synopsis: F = iahwt(f)





>>> iashow(f)

>>> F = iahwt(f)




C.7.10 iaidctPurpose: Inverse Discrete Cossine Transform.

Synopsis: F = iaidct(f)



Examples:>>> f = iaread(’cameraman.pgm’)

>>> iashow(f)

>>> F = iadct(f)

>>> g = iaidct(F)

>>> print Numeric.sum(Numeric.sum(abs(f-g)))

1.3993287657e-07

(f)

C.7.11 iaidftPurpose: Inverse Discrete Fourier Transform.

Synopsis: f = iaidft(F)

Input:F <type ’array’>

Output:f <type ’array’>



>>> F = iadft(f)

>>> H = iagaussian(F.shape, Numeric.array(F.shape)/2., [[50,0],[0,50]])

>>> H = ianormalize(H,[0,1])

>>> FH = F * iaifftshift(H)

>>> print iaisdftsym(FH)

1

>>> g=iaidft(FH)

>>> iashow(f)


>>> iashow(ianormalize(H,[0,255]))

>>> iashow(iadftview(FH))

>>> iashow(abs(g))


(f) (iadftview(F)) (ianormalize(H,[0,255])) (iadftview(FH))

(abs(g))

Equation:

f(x) =1

N

N−1∑

u=0

F (u) exp(j2πux

N)

0 ≤ x < N, 0 ≤ u < N

f =1√N

(AN )∗F

f(x, y) =1

NM

N−1∑

u=0

M−1∑

v=0

F (u, v) exp(j2π(ux

N+

vy

M))

(0, 0) ≤ (x, y) < (N, M), (0, 0) ≤ (u, v) < (N, M)

f =1√NM

(AN )∗F (AM )∗

See also: iadft (C.7.3), iaisdftsym (C.7.15)

C.7.12 iaifftshiftPurpose: Undoes the effects of iafftshift.

Synopsis: HS = iaifftshift(H)

Input:H <type ’array’> DFT image with (0,0) in the center.

Output:HS <type ’array’> DFT image with (0,0) in the top-left corner.

Equation:

HS = Hxo,yo

xo = d−W/2eyo = d−H/2e

See also: iafftshift (C.7.5), iaptrans (C.6.3)


C.7.13 iaihadamardPurpose: Inverse Hadamard Transform.

Synopsis: F = iaihadamard(f)





>>> iashow(f)

>>> F = iahadamard(f)

>>> g = iaihadamard(F)

>>> print Numeric.sum(Numeric.sum(abs(f.astype(Numeric.Float)-g.astype(Numeric.Float)←↩)))

0.0

(f)

C.7.14 iaihwtPurpose: Inverse Haar Wavelet Transform.

Synopsis: F = iaihwt(f)





>>> iashow(f)

>>> F = iahwt(f)

>>> g = iaihwt(F)

>>> print Numeric.sum(Numeric.sum(abs(f.astype(Numeric.Float)-g.astype(Numeric.Float)←↩)))

4.29271901825e-10

(f)


C.7.15 iaisdftsymPurpose: Check for conjugate symmetry

Synopsis: b = iaisdftsym(F)

Input:F <type ’array’> Complex image.

Output:b <type ’int’>

Description: Verify if a complex array show the conjugate simmetry. Due to numerical precision, thiscomparison is not exact but with within a small tolerance (10E-4). This comparison is usefulto verify if the result of a filtering in the frequency domain is correct. Before taking the inverseDCT, the Fourier transform must be conjugate symmetric so that its inverse is a real function(an image).

Examples:>>> import FFT, MLab

>>> print iaisdftsym(FFT.fft2d(MLab.rand(100,100)))

1


1


1

>>> print iaisdftsym(iabwlp([10,10], 8, 5))

1

>>> print iaisdftsym(iabwlp([11,11], 8, 5))

0

Equation:

F (u, v) = F ?(−u mod N,−v mod M)

(0, 0) ≤ (u, v) < (N, M)

See also: iadft (C.7.3), iaidft (C.7.11)

C.8 Image Filtering

C.8.1 iacontourPurpose: Contours of binary images.

Synopsis: g = iacontour(f)

Input:f <type ’array’> input image


Description: Contours of binary images.

C.8. IMAGE FILTERING 117

Examples:>>> f = iaread(’blobs.pbm’)

>>> g = iacontour(f)

>>> iashow(f)

>>> iashow(g)

(f) (g)

C.8.2 iaconvPurpose: 2D convolution.

Synopsis: g = iaconv(f, h)

Input:f <type ’array’> input image.h <type ’array’> PSF (point spread function), or kernel. The origin is at the

array center.


Description: Perform a 2D discrete convolution. The kernel origin is at the center of image h.


>>> f = Numeric.zeros((5,5))

>>> f[2,2] = 1

>>> print f

[[0 0 0 0 0]

[0 0 0 0 0]

[0 0 1 0 0]

[0 0 0 0 0]

[0 0 0 0 0]]

>>> h = Numeric.array([[1,2,3],[4,5,6]])

>>> print h

[[1 2 3]

[4 5 6]]

>>> a = iaconv(f,h)

>>> print a

[[0 0 0 0 0 0 0]

[0 0 0 0 0 0 0]

[0 0 1 2 3 0 0]

[0 0 4 5 6 0 0]

[0 0 0 0 0 0 0]

[0 0 0 0 0 0 0]]

>>> f = Numeric.array([[1,0,0,0],[0,0,0,0]])

>>> print f

[[1 0 0 0]

[0 0 0 0]]

>>> h = Numeric.array([1,2,3])


>>> print h

[1 2 3]

>>> a = iaconv(f,h)

>>> print a

[[1 2 3 0 0 0]

[0 0 0 0 0 0]]

>>> f = Numeric.array([[1,0,0,0,0,0],[0,0,0,0,0,0]])

>>> print f

[[1 0 0 0 0 0]

[0 0 0 0 0 0]]

>>> h = Numeric.array([1,2,3,4])

>>> print h

[1 2 3 4]

>>> a = iaconv(f,h)

>>> print a

[[1 2 3 4 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0]]


>>> h = [[1,2,1],[0,0,0],[-1,-2,-1]]

>>> g = iaconv(f,h)

>>> gn = ianormalize(g, [0,255])

>>> iashow(gn)

(gn)

Equation:

(f ∗ h)(x, y) =1

NM

N−1∑

i=0

M−1∑

j=0

fe(i, j)he(x− i, y − j)

fe(x, y) =

{

f(x, y), 0 ≤ x ≤ A− 1 and 0 ≤ y ≤ B − 10, A ≤ x ≤ N − 1 or B ≤ y ≤M − 1

he(x, y) =

{

f(x, y), 0 ≤ x ≤ C − 1 and 0 ≤ y ≤ D − 10, C ≤ x ≤ N − 1 or D ≤ y ≤M − 1

N ≤ A + C − 1

M ≤ B + D − 1

See also: iaconv (C.8.2)

C.8.3 ialogfilterPurpose: Laplacian of Gaussian filter.

Synopsis: g = ialogfilter(f, sigma)


sigma <type ’float’> scaling factor



Description: Filters the image f by the Laplacian of Gaussian (LoG) filter with parameter sigma. Thisfilter is also known as the Marr-Hildreth filter. Obs: to better efficiency, this implementationcomputes the filter in the frequency domain.



>>> iashow(f)

>>> g07 = ialogfilter(f, 0.7)

>>> iashow(g07)

>>> iashow(g07 > 0)

(f) (g07) (g07 > 0)

>>> import Numeric

>>> g5 = ialogfilter(f, 5)

>>> iashow(g5)

>>> iashow(g5 > 0)

>>> g10 = ialogfilter(f, 10)

>>> iashow(g10)

>>> iashow(g10 > 0)

(g5) (g5 > 0) (g10) (g10 > 0)

C.8.4 iapconvPurpose: 2D Periodic convolution.

Synopsis: g = iapconv(f, h)

Input:f <type ’array’> Input image.h <type ’array’> PSF (point spread function), or kernel. The origin is at the

array center.


Description: Perform a 2D discrete periodic convolution. The kernel origin is at the center of imageh. Both image and kernel are periodic with same period. Usually the kernel h is smaller than theimage f, so h is padded with zero until the size of f.



>>> f = Numeric.zeros((5,5))

>>> f[2,2] = 1

>>> print f

[[0 0 0 0 0]

[0 0 0 0 0]

[0 0 1 0 0]

[0 0 0 0 0]

[0 0 0 0 0]]

>>> h = Numeric.array([[1,2,3],[4,5,6]])

>>> print h

[[1 2 3]

[4 5 6]]

>>> a = iapconv(f,h)

>>> print a

[[ 0. 0. 0. 0. 0.]

[ 0. 0. 0. 0. 0.]

[ 0. 1. 2. 3. 0.]

[ 0. 4. 5. 6. 0.]

[ 0. 0. 0. 0. 0.]]

>>> f = Numeric.array([[1,0,0,0],[0,0,0,0]])

>>> print f

[[1 0 0 0]

[0 0 0 0]]

>>> h = Numeric.array([1,2,3])

>>> print h

[1 2 3]


>>> print a

[[ 2. 3. 0. 1.]

[ 0. 0. 0. 0.]]

>>> f = Numeric.array([[1,0,0,0,0,0],[0,0,0,0,0,0]])

>>> print f

[[1 0 0 0 0 0]

[0 0 0 0 0 0]]

>>> h = Numeric.array([1,2,3,4])

>>> print h

[1 2 3 4]


>>> print a

[[ 2. 3. 4. 0. 0. 1.]

[ 0. 0. 0. 0. 0. 0.]]


>>> h = [[1,2,1],[0,0,0],[-1,-2,-1]]

>>> g = iapconv(f,h)

>>> gn = ianormalize(g, [0,255])

>>> iashow(gn)

(gn)


Equation:

(f ∗N h)(x) =

N−1∑

i=0

f(i)h(mod(x− i, N))

f(x) = f(x + kN), h(x) = h(x + kN)

mod(x, N) = x−Nb x

Nc

(f ∗(N,M) h)(x, y) =

N−1∑

i=0

M−1∑

j=0

f(i, j)h(mod(x− i, N), mod(y − j, M))

See also: iaconv (C.8.2), iaptrans (C.6.3)

C.8.5 iasobelPurpose: Sobel edge detection.

Synopsis: mag, theta = iasobel(f)


Output:mag, theta <type ’array’>

Description: Computes the edge detection by Sobel. Compute magnitude and angle.



>>> (g,a) = iasobel(f)

>>> iashow(g)

>>> iashow(Numeric.log(g+1))

(g) (Numeric.log(g+1))

>>> iashow(g > 150)

>>> i = Numeric.nonzero(Numeric.ravel(g > 150))

>>> z = Numeric.zeros(a.shape)

>>> Numeric.put(Numeric.ravel(z), i, Numeric.take(Numeric.ravel(a), i))

>>> iashow(z)


(g > 150) (z)

Equation:

fsobel =√

f2x + f2

y

ftheta = arctan

(

fy

fx

)

fx = (f ∗(N,M) Sx)

fy = (f ∗(N,M) Sy)

Sx =

1 2 10 0 0−1 −2 −1

Sy =

1 0 −12 0 −21 0 −1

C.8.6 iavarfilterPurpose: Variance filter.

Synopsis: g = iavarfilter(f, h)

Input:f <type ’array’> input image.h <type ’array’> scaling factor.


Description: Computes the variance on the neighborhood of the pixel. The neighborhood is given by theset marked by the kernel elements.

Examples:>>> f = iaread(’cameraman.pgm’)

>>> iashow(f)

>>> g = iavarfilter(f, [[0,1,0],[1,1,1],[0,1,0]])

>>> iashow(g)

(f) (g)

C.9. AUTOMATIC THRESHOLDING TECHNIQUES 123

C.9 Automatic Thresholding Techniques

C.9.1 iaotsuPurpose: Thresholding by Otsu.

Synopsis: t, eta = iaotsu(f)


Output:t, eta <type ’float’> Maximum of this result is the thresholding.

Description: Compute the automatic thresholding level of a gray scale image based on the Otsu method.


>>> f = iaread(’cookies.pgm’)

>>> iashow(f)

>>> (t, eta) = iaotsu(f)

>>> print ’threshold at %f, goodness=%f’ %(t, eta)

threshold at 90.000000, goodness=0.938940

>>> iashow(f > t)

(f) (f > t)

Equation:

H(u, v) =1

1 + (√

2− 1)(√

( uN

)2 + ( vM

)2 tc)2n

(u, v) ∈ {−bN2c : N − bN

2c − 1,−bM

2c : M − bM

2c − 1}

tc ∈ {2 : max{N, M}}

C.10 Measurements

C.10.1 iacolorhistPurpose: Color-image histogram.

Synopsis: hc = iacolorhist(f, mask=None)


mask <type ’array’>

Output:hc <type ’array’>


Description: Compute the histogram of a color image and return a graphical image suitable for visua-lization with the 3 marginal histograms: red-green at top-left, blue-green at top-right and red-blueat bottom-left. If the optional mask image is available, the histogram is computed only for thosepixels under the mask.


>>> iashow(f)

>>> hc = iacolorhist(f)

>>> iashow(hc)

>>> iashow(Numeric.log(hc+1))

(f) (hc) (Numeric.log(hc+1))

C.10.2 iahistogramPurpose: Image histogram.

Synopsis: h = iahistogram(f)


Output:h <type ’array’>

Examples:>>> f = iaread(’woodlog.pgm’)

>>> iashow(f)

>>> h = iahistogram(f)

>>> g,d = iaplot(h)

>>> g(’set data style boxes’)

>>> g.plot(d)

(f)

0

100

200

300

400

500

600

700

0 50 100 150 200 250 300

(h)

Equation:

h(vi) = card{p|f(p) = vi}

C.10.3 ialabelPurpose: Label a binary image.

C.10. MEASUREMENTS 125

Synopsis: g = ialabel(f)



Description: Creates an image by labeling the connect components of the input binary image. Thebackground pixels (with value 0) are not labeled. The maximum label value in the output imagegives the number of its connected components.

Examples:>>> f = Numeric.array([[0,1,0,1,1], [1,0,0,1,0]])

>>> print f

[[0 1 0 1 1]

[1 0 0 1 0]]

>>> g = ialabel(f)

>>> print g

[[0 1 0 2 2]

[3 0 0 2 0]]

>>> f = iaread(’blobs.pbm’)

>>> g = ialabel(f);

>>> nblobs = max(Numeric.ravel(g))

>>> print nblobs

18

>>> iashow(f)

>>> iashow(ialblshow(g))

(f) (ialblshow(g))

C.10.4 iarecPurpose: Reconstruction of a connect component.

Synopsis: g = iarec(f, seed)


seed <type ’array’> seed coordinate


Description: Extracts a connect component of an image by region growing from a seed.

Examples:>>> f = Numeric.array([[0,1,0,1,1], [1,0,0,1,0]])

>>> print f

[[0 1 0 1 1]

[1 0 0 1 0]]


>>> g = iarec(f, [0,3])

>>> print g

[[0 0 0 1 1]

[0 0 0 1 0]]

C.10.5 iastatPurpose: Calculates MSE, PSNR and Pearson correlation between two images.

Synopsis: MSE, PSNR, PC = iastat(f1, f2)

Input:f1 <type ’array’> Input image 1.f2 <type ’array’> Input image 2 (Ex.: input image 1 degraded).

Output:MSE, PSNR, PC <type ’float’> Mean Square Error; Peak Signal Noise Ratio; Correlation of

the product of the moments of Pearson (r). If r is +1 then there is a perfectlinear relation between f1 and f2. If r is -1 then there is a perfect linearnegative relation between f1 and f2.

Description: Calculates the mean square error (MSE), the peak signal noise ratio (PSNR), and thecorrelation of the product of the moments of Pearson (PC), between two images.

Examples:>>> f1 = Numeric.array([[2,5,3],[4,1,2]])

>>> print f1

[[2 5 3]

[4 1 2]]

>>> f2 = Numeric.array([[4,9,5],[8,3,3]])

>>> print f2

[[4 9 5]

[8 3 3]]

>>> (mse, psnr, pc) = iastat(f1, f2)

>>> print mse

7.5

>>> print psnr

0.697381335929

>>> print pc

0.964763821238

Equation:

MSE =1

NhNw

∑

[

(f1 − f2)2]

PSNR = 20log10Ypeak√MSE

PC = r =

∑

f1f2 −∑

f1

∑f2

N√

[

∑

f21 −

(∑

f1)2

N

]

.[

∑

f22 −

(∑

f2)2

N

]

C.11. HALFTONING APPROXIMATION 127

C.11 Halftoning Approximation

C.11.1 iaditherPurpose: Ordered Dither.

Synopsis: g = iadither(f, n)

Input:f <type ’array’> input imagen <type ’array’> dimension of the base matrix


Description: Ordered dither (Bayer 1973).

Examples:>>> f1 = iaramp([20,150], 256, [0,255])

>>> f2 = iaresize(iaread(’woodlog.pgm’), [150,150])

>>> f = Numeric.concatenate((f1, f2))

>>> g_4 = iadither(f, 4)

>>> g_32 = iadither(f, 32)

>>> iashow(f)

>>> iashow(g_4)

>>> iashow(g_32)

(f) (g_4) (g_32)

C.11.2 iafloydPurpose: Floyd-Steinberg error diffusion.

Synopsis: g = iafloyd(f)



Description: Floyd-Steinberg error diffusion (1976).

Examples:>>> f1 = iaramp([20,150], 256, [0,255])

>>> f2 = iaresize(iaread(’woodlog.pgm’), [150,150])

>>> f = Numeric.concatenate((f1, f2))

>>> g = iafloyd(f)

>>> iashow(f)

>>> iashow(g)


(f) (g)

C.12 Visualization

C.12.1 iadftviewPurpose: Generate optical Fourier Spectrum for display from DFT data.

Synopsis: G = iadftview(F)

Input:F <type ’array’> DFT complex data. F(1,1) is the center of the spectrum

(u,v)=(0,0)

Output:G <type ’array’> uint8 image suitable for displaying

Description: Generate the logarithm of the magnitude of F, shifted so that the (0,0) stays at the centerof the image. This is suitable for displaying only.

Examples:>>> import FFT


>>> iashow(f)



>>> iashow(Fv)

(f) (Fv)

Equation:

Gaux = log(|Fxc,yc|+ 1)

xc = bW/2cyc = bH/2cG = Gaux|2550

See also: iadft (C.7.3), iaidft (C.7.11), iafftshift (C.7.5)

C.12. VISUALIZATION 129

C.12.2 iagshowPurpose: Matrix of the image display.

Synopsis: g = iagshow(f)

Input:f <type ’array’> Image.


Description: Return the matrix of the image display.

See also: iashow (C.12.6)

C.12.3 iaisolinesPurpose: Isolines of a grayscale image.

Synopsis: g = iaisolines(f, nc=10, np=1)

Input:f <type ’array’> Input image.

nc <type ’float’> Number of colors.np <type ’float’> Number of pixels by isoline.

Output:g <type ’array’> Input image with color isolines.

Description: Shows lines where the pixels have same intensity with a unique color.

Examples:>>> f = ianormalize(iabwlp([150,150], 4, 1), [0,255]).astype(’b’)

>>> g = iaisolines(f, 10, 3)

>>> iashow(f)

>>> iashow(g)

(f) (g)

C.12.4 ialblshowPurpose: Display a labeled image assigning a random color for each label.

Synopsis: g = ialblshow(f)




Description: Displays the labeled input image (uint8 or uint16) with a pseudo color where each labelappears with a random color.

Examples:>>> f = iaread(’blobs.pbm’)

>>> g = ialabel(f);

>>> iashow(g)

>>> iashow(ialblshow(g))

(g) (ialblshow(g))

C.12.5 iaplotPurpose: Plot a function.

Synopsis: g, d = iaplot(x=0, y=None, filename=None)

Input:x <type ’array’> x.y <type ’array’> f(x).

filename <type ’str’> Name of the postscript file.

Output:g <type ’str’> Gnuplot pointer.d <type ’str’> Gnuplot data.

Description: Plot a 2D function y=f(x).


>>> x = Numeric.arange(0, 2*Numeric.pi, 0.1)

>>> y = Numeric.sin(x)

>>> g, d = iaplot(x,y)

>>> g(’set data style impulses’)

>>> g(’set grid’)

>>> g(’set xlabel "X values" -20,0’)

>>> g(’set ylabel "Y values"’)

>>> g(’set title "Example Plot"’)

>>> g.plot(d, ’cos(x)’)

-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

0 1 2 3 4 5 6 7

Y v

alue

s

X values

Example Plot

cos(x)

(d, ’cos(x)’)

C.12. VISUALIZATION 131

C.12.6 iashowPurpose: Image display.

Synopsis: g = iashow(f)

Input:f <type ’array’> Image.


Description: Display an image.


>>> iashow(f)

(f)

>>> f = iaread(’club.pgm’)

>>> iashow(f)

(f)

>>> import Numeric

>>> f = Numeric.resize(range(256), (256,256))

>>> iashow(f)

(f)

>>> import Numeric

>>> f = Numeric.resize(range(-100,100), (100,200))

>>> iashow(f)

(f)


>>> aux,k = iasobel(f)

>>> g = aux > 100

>>> iashow(f)

>>> iashow(g)


>>> iashow((f,g))

(f) (g) ((f,g))


>>> iashow(f)

>>> iashow((f,f>100,f>130,f>150,f>180,f>220,f==255))

(f) ((f,f>100,f>130,f>150,f>180,f>220,f==255))

See also: iagshow (C.12.2)

C.12.7 iasplotPurpose: Plot a surface.

Synopsis: g, d = iasplot(x=0, y=None, z=None, filename=None)

Input:x <type ’array’> x range.y <type ’array’> y range.z <type ’array’> object function (z=f(x,y)).

filename <type ’str’> Name of the postscript file.

Output:g <type ’str’> Gnuplot pointer.d <type ’str’> Gnuplot data.

Description: Plot a 3D function z=f(x,y).

Examples:>>> x = Numeric.arange(35)/2.0

>>> y = Numeric.arange(30)/10.0 - 1.5

>>> def z(x,y): return 1.0 / (1 + 0.01 * x**2 + 0.5 * y**2)

>>> g,d = iasplot(x, y, z) 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2

0 2 4 6 8 10 12 14 16 18 -1.5-1

-0.50

0.51

1.5

0.10.20.30.40.50.60.70.80.9

1

(z)


>>> k = f[90:195, 70:150]

>>> iashow(k)

>>> g,d = iasplot(k)

C.13. FUNCTIONS 133

>>> g(’set view 30,60’)

>>> g.splot(d) # surface

>>> g(’set view 0,90’)

>>> g(’set nosurface’) # level curves

>>> g.splot(d)

(k)

200 150 100 50

0

20

40

60

80

100

12010

2030

4050

6070

80

406080

100120140160180200220

(Surface of k)

200 150 100 50

0

20

40

60

80

100

1200 10 20 30 40 50 60 70 80

(Level curves of k)

C.13 Functions

C.13.1 iaerrorPurpose: Print message of error.

Synopsis: iaerror(msg)

Input:msg <type ’str’> Error message.

C.13.2 iahelpPurpose: Print the help of a function.

Synopsis: iahelp(obj)

Input:obj <type ’NoneType’> Object name.

Examples:>>> iahelp(iacos)

- Purpose

Create a cossenoidal image.

- Synopsis

f = iacos(s, t, theta, phi=0)

- Input

s: size: [rows cols].

t: period: in pixels.

theta: spatial direction of the wave, in radians. 0 is a wave on

the horizontal direction.

phi: phase

- Output

f:

- Description

Generate a cosenosoid image of size s with amplitude 1, period

T, phase phi and wave direction of theta. The output image is a

double array.


- Examples

#

# example 1

#

import Numeric

f = iacos((5,10), 6, Numeric.pi/3)

print Numeric.array2string(f, precision=2, suppress small=1)

#

# example 2

#

f = iacos([256,256], 100, Numeric.pi/4)

iashow(f)


showfig(f[0])

C.13.3 iatypePurpose: Print the source code of a function.

Synopsis: iatype(obj)

Input:obj <type ’NoneType’> Object name.

Examples:>>> iatype(iacos)

def iacos(s, t, theta, phi=0):

"

- Purpose

Create a cossenoidal image.

- Synopsis

f = iacos(s, t, theta, phi=0)

- Input

s: size: [rows cols].

t: period: in pixels.

theta: spatial direction of the wave, in radians. 0 is a wave on

the horizontal direction.

phi: phase

- Output

f:

- Description

Generate a cosenosoid image of size s with amplitude 1, period

T, phase phi and wave direction of theta. The output image is a

double array.

- Examples

#

# example 1

#

import Numeric

f = iacos((5,10), 6, Numeric.pi/3)

print Numeric.array2string(f, precision=2, suppress small=1)

#

# example 2

#

f = iacos([256,256], 100, Numeric.pi/4)

C.13. FUNCTIONS 135

iashow(f)


showfig(f[0])

"

from Numeric import cos, sin, pi

cols, rows = s[1], s[0]

(x, y) = iameshgrid(range(cols),range(rows))

freq = 1./t

fcols = freq * cos(theta)

frows = freq * sin(theta)

f = cos(2*pi*(fcols*x + frows*y) + phi)

return f

C.13.4 iauniquePurpose: Set unique.

Synopsis: t, i, j = iaunique(f)

Input:f <type ’array’> Set initial.

Output:t <type ’array’>i <type ’array’>j <type ’array’>

Description: Returns the set unique.

Examples:>>> c = Numeric.array([2, 10, 5, 5, 10, 7, 5])

>>> print c

[ 2 10 5 5 10 7 5]

>>> (u,i,j) = iaunique(c)

>>> print u

[ 2 5 7 10]

>>> print i

[0 6 5 4]

>>> print j

[0 3 1 1 3 2 1]

Apendice D

Lessons

D.1 iaconvteoIllustrate the convolution theorem

Reading and ROI selection. The image is read and displayed

>>> fin = iaread(’lenina.pgm’)

>>> iashow(fin)

>>> froi = iaroi(fin, (90,70), (200,180))

>>> iashow(froi)

(fin) (froi)

Convolution with the Laplacian kernel. The image is convolved (periodicaly) with the 3x3Laplacian kernel

>>> import Numeric

>>> fd = froi.astype(Numeric.Float)

>>> h = Numeric.array([[-2,-1,0],[-1,0,1],[0,1,2]])

>>> g = iapconv(fd,h)

>>> iashow(g)

(g)

Equivalent filter in frequency domain. The 3x3 kernel is zero padded to the size of the input imageand periodicaly translated so that the center of the kernel stays at the top-left image corner. Its

137

138 APENDICE D. LESSONS

spectrum is visualized.

>>> hx = Numeric.zeros(Numeric.array(froi.shape))

>>> hx[:h.shape[0],:h.shape[1]] = h

>>> hx = iaptrans(hx,-Numeric.floor((Numeric.array(h.shape)-1)/2).astype(Numeric.Int)←↩)

>>> H = iadft(hx);

>>> iashow(iadftview(H))

(iadftview(H))

Filtering in the frequency domain. The image is filtered by multiplying its DFT by the frequencymask computed in the previous step.

>>> F = iadft(fd)

>>> G = F * H

>>> print "Is symmetrical:", iaisdftsym(G)

Is symmetrical: 1

>>> iashow(iadftview(G))

>>> g_aux = iaidft(G).real

>>> iashow(g_aux)

(iadftview(G)) (g_aux)

Comparing the results. Both images, filtered by the convolution and filtered in the frequency domainare compared to see that they are the same. The small differencies are due to numerical precisionerrors.

>>> e = abs(g - g_aux)

>>> print "Max error:", max(Numeric.ravel(e))

Max error: 4.25410817684e-11

D.2 iacorrdemoIllustrate the Template Matching technique

Image read and pattern selection. We have a gray scale image and a pattern extracting from theimage.

>>> import Numeric


>>> f = Numeric.asarray(f).astype(Numeric.Float)

>>> iashow(f)

>>> w = f[25:25+17,106:106+17]

>>> iashow(w)

D.2. IACORRDEMO 139

(f) (w)

Image correlation. Pure image correlation is not good for template matching because it depends onthe mean gray value in the image, so light regions gives higher score than dark regions. Anormalization factor can be used which improves the template matching.

>>> w1 = w[::-1,::-1]

>>> iashow(w1)

>>> g = iapconv(f, w1)

>>> iashow(g)

>>> i = Numeric.ones(Numeric.shape(w1))

>>> fm2 = iapconv(f*f, i)

>>> g2 = g/Numeric.sqrt(fm2)

>>> iashow(g2)

>>> v, pos = max(Numeric.ravel(g2)), Numeric.argmax(Numeric.ravel(g2))

>>> (row, col) = iaind2sub(g2.shape, pos)

>>> print ’found best match at (%3.0f,%3.0f)’ %(col,row)

found best match at (114, 33)

(w1) (g) (g2)

Correlation index. A better pattern matching is achievied subtrating the mean value on the imageapplication.

>>> import MLab

>>> n = Numeric.product(w.shape)

>>> wm = MLab.mean(Numeric.ravel(w))

>>> fm = 1.*iapconv(f,i)/n

>>> num = g - (n*fm*wm)

>>> iashow(num)

>>> den = Numeric.sqrt(fm2 - (n*fm*fm))

>>> iashow(den)

>>> cn = 1.*num/den

>>> iashow(cn)

>>> v, pos = max(Numeric.ravel(cn)), Numeric.argmax(Numeric.ravel(cn))

>>> (row, col) = iaind2sub(g2.shape, pos)

>>> print ’found best match at (%3.0f,%3.0f)’ %(col,row)

found best match at (114, 33)

(num) (den) (cn)


D.3 iadftdecomposeIllustrate the decomposition of the image in primitive 2-D waves.

Step function image. The image is created using.

>>> import Numeric

>>> f = Numeric.ones((128, 128)) * 50

>>> x, y = [], map(lambda k:k%128, range(-32,32))

>>> for i in range(128): x = x + (len(y) * [i])

>>> y = 128 * y

>>> Numeric.put(f, iasub2ind([128,128], x, y), 200)

>>> iashow(f)

(f)

Discrete Fourier Transform. The DFT is computed and displayed

>>> F = iadft(f)

>>> E = iadftview(F)

>>> iashow(E)

>>> g,d = iaplot(iafftshift(F[:,0]).real)

>>> g(’set data style impulses’)

>>> g.plot(d)

(E)

-500000

0

500000

1e+06

1.5e+06

2e+06

2.5e+06

0 20 40 60 80 100 120 140

(central_line)

D.4 iadftexamplesDemonstrate the DFT spectrum of simple synthetic images.

Constant image. The DFT of a constant image is a single point at F(0,0), which gives the sum of allpixels in the image.

>>> import Numeric, FFT

>>> f = 50 * Numeric.ones((10, 20))


>>> aux = F.real > 1E-5

>>> r, c = iaind2sub([10, 20], Numeric.nonzero(Numeric.ravel(aux)))

>>> print r

[0]

>>> print c

[0]

>>> print F[r[0],c[0]]/(10.*20.)

(50+0j)

D.4. IADFTEXAMPLES 141

Square. The DFT of a square image is a digital sync.

>>> f = Numeric.zeros((128, 128))

>>> f[63:63+5,63:63+5] = 1

>>> iashow(f)



>>> iashow(Fv)

(f) (Fv)

Pyramid. The DFT of a pyramid is the square of the digital sync.

>>> f = Numeric.zeros((128, 128))

>>> k = Numeric.array([[1,2,3,4,5,6,5,4,3,2,1]])

>>> k2 = Numeric.matrixmultiply(Numeric.transpose(k), k)

>>> f[63:63+k2.shape[0], 63:63+k2.shape[1]] = k2

>>> iashow(f)



>>> iashow(Fv)

(f) (Fv)

Gaussian. The DFT of a Gaussian image is a Gaussian image.

>>> f = iagaussian([128,128],[65,65],[[3*3,0],[0,5*5]])

>>> fn = ianormalize(f,[0,255])

>>> iashow(fn)



>>> iashow(Fv)

(fn) (Fv)

Impulse. The DFT of an impulse image is an impulse image.

>>> f = iacomb((128,128), (4,4), (0,0))

>>> fn = ianormalize(f, (0,255))

>>> iashow(fn)




>>> iashow(Fv)

(fn) (Fv)

D.5 iadftmatrixexamplesDemonstrate the kernel matrix for the DFT Transform.

Kernel images generated. Imaginary and real parts of the DFT kernel.


>>> Aimag, Areal = A.imag, A.real

>>> iashow(Aimag)

>>> iashow(Areal)

(Aimag) (Areal)

Three first lines. Three first lines from imaginary and real parts of the kernel matrix. Observe theincreasing frequencies of the senoidals (imaginary part) and cossenoidals (real part).

>>> g,i1 = iaplot(Aimag[0,:])



>>> g.plot(i1,i2,i3)

>>> g,r1 = iaplot(Areal[0,:])



>>> g.plot(r1,r2,r3)

-0.1

-0.08

-0.06

-0.04

-0.02

0

0.02

0.04

0.06

0.08

0.1

0 20 40 60 80 100 120 140

(i1,i2,i3)

-0.1

-0.08

-0.06

-0.04

-0.02

0

0.02

0.04

0.06

0.08

0.1

0 20 40 60 80 100 120 140

(r1,r2,r3)

D.6 iadftscalepropertyIllustrate the scale property of the Discrete Fourier Transform.

Image read, ROI selection and display. The image is read and a small portion (64x64) is selected.

D.6. IADFTSCALEPROPERTY 143


>>> froi = f[19:19+64,99:99+64] # ROI selection

>>> iashow(f)

>>> iashow(froi)

(f) (froi)

DFT of the ROI image. The DFT of the ROI image is taken and its spectrum is displayed



>>> F = FFT.fft2d(fd) # F is the DFT of f

>>> iashow(froi)


(froi) (iadftview(F))

Image expansion (without interpolation) and DFT. The image is expanded by 4, but filling thenew pixels with 0

>>> fx4 = Numeric.zeros(4*Numeric.array(froi.shape)) # size is 4 times larger

>>> fx4[::4,::4] = froi # filling the expanded image

>>> iashow(froi)

>>> iashow(fx4)

(froi) (fx4)

DFT of the expansion without interpolation. the resulting DFT is a periodical replication of theoriginal DFT.

>>> fdx4 = fx4.astype(Numeric.Float)

>>> Fx4 = FFT.fft2d(fdx4) # Fx4 is the DFT of fx4 (expanded f)


>>> iashow(iadftview(Fx4))

(iadftview(F)) (iadftview(Fx4))


Comparing in the frequency domain.. Alternatively, the original DFT (F) is replicated by 4 ineach direction and compared with the DFT of the expanded image. For quantitative comparison,both the sum of the absolute errors of all pixels is computed and displayed.

>>> aux = Numeric.concatenate((F,F,F,F))

>>> FFx4 = Numeric.concatenate((aux,aux,aux,aux), 1) # replicate the DFT of f

>>> iashow(iadftview(FFx4))

>>> diff = abs(FFx4 - Fx4) # compare the replicated DFT wit←↩h DFT of expanded f

>>> print Numeric.sum(Numeric.ravel(diff)) # print the error signal power

9.02333430744e-09

(iadftview(FFx4))

Comparing in the spatial domain..

>>> ffdx4 = FFT.inverse_fft2d(FFx4)

>>> fimag = ffdx4.imag

>>> print Numeric.sum(Numeric.ravel(fimag))

5.04870979341e-29

>>> ffdx4 = Numeric.floor(0.5 + ffdx4.real) # round

>>> iashow(ffdx4.astype(Numeric.Int))

>>> error = abs(fdx4 - ffdx4)

>>> print Numeric.sum(Numeric.ravel(error))

0.0

(ffdx4.astype(Numeric.Int))

D.7 iagenimagesIllustrate the generation of different images

Gaussian images. A gaussian image is controled by its mean and variance.

>>> f1 = iagaussian([256,256], [128,128], [[50*50,0],[0,80*80]])

>>> fn = ianormalize(f1, [0,255])

>>> iashow(fn)

>>> g,d = iasplot(iaresize(fn, [32,32]))

>>> iashow(fn > 128)

(fn)

250 200 150 100 50

05

1015

2025

3035 0

510

1520

2530

35

0

50

100

150

200

250

300

(fn) (fn > 128)

D.7. IAGENIMAGES 145

Difference of two Gaussian images. The difference of two gaussian images gives a Laplacian image.

>>> f2 = iagaussian([256,256], [128,128], [[25*25,0],[0,40*40]])

>>> fn2 = ianormalize(f2, [0,255])

>>> f = f1 - f2/5.

>>> fn = ianormalize(f, [0,255])

>>> iashow(fn2)

>>> iashow(fn)

>>> g,d = iasplot(iaresize(fn, [32,32]))


(fn2) (fn)

250 200 150 100 50

05

1015

2025

3035 0

510

1520

2530

35

0

50

100

150

200

250

300

(fn) (fn > 230)

Sinusoidal images. A bidimensional sinusoidal image depends on its period, phase, and direction ofthe wave.

>>> import Numeric

>>> f1 = iacos([128,256], 100, Numeric.pi/4, 0)

>>> fn = ianormalize(f1, [0,255])

>>> iashow(fn)


(fn) (fn > 128)

Multiplication of two sinusoidal images. The multiplication of two sinusoidal images gives a kindof a grid of hills and depressions.

>>> f2 = iacos([128,256], 40, Numeric.pi/8, 0)


>>> f = f1 * f2


>>> iashow(fn2)

>>> iashow(fn)


(fn2) (fn) (fn > 128)

Another example of multiplication of two sinusoidal images. In this case, the waves areorthogonal to each other.

>>> f3 = iacos([128,256], 40, (Numeric.pi/8)+(Numeric.pi/2), 0)


>>> f = f2 * f3


>>> iashow(fn2)


>>> iashow(fn)


(fn2) (fn) (fn > 190)

Maximum of two sinusoidal images. The maximum of two sinusoidal images gives a kind of asurface of the union of both waves. They look like pipes

>>> f = Numeric.maximum(f1, f2)


>>> iashow(fn)


(fn) (fn > 200)

Sinusoidal where x and y are multiplied. If the arguments of the cos are multiplied instead ofadded as before, we have a rather interesting pattern. It is important to remember that theproper sinusoidal image that are related to Fourier transforms are the bidimensional sinusoideshown earlier

>>> x,y = iameshgrid(range(256), range(256))

>>> f = Numeric.cos((2*Numeric.pi*x/256) * (2*Numeric.pi*y/256))


>>> iashow(fn)


(fn) (fn > 200)

Sinusoidal with varying period. If the arguments of the cos are taking at the power of a number,we have a varying period effect


>>> f = Numeric.cos(2*Numeric.pi* (x/80. + y/150.)**3)


>>> iashow(fn)


(fn) (fn > 200)

Sinusoidal with sinusoidal period. In this case the arguments of the cos are the multiplication of xand cos(y)

D.8. IAHISTEQ 147


>>> f = Numeric.cos(2*Numeric.pi*(x/80.) * Numeric.cos(2*Numeric.pi*(y/150.)))


>>> iashow(fn)


(fn) (fn > 200)

Saddle point function. The multiplication of x and y gives a surface with saddle point

>>> x,y = iameshgrid(range(-75,75), range(-75,75))

>>> f = x * y

>>> fn = ianormalize(f, [0,255]).astype(’b’)

>>> iashow(fn)

>>> iashow(iaisolines(fn,9))

(fn) (iaisolines(fn,9))

D.8 iahisteqIllustrate how to make a histogram equalization

Computing the normalized cumulative histogram (NCH). ...

>>> import Numeric, MLab

>>> f = iaread(’woodlog.pgm’)

>>> iashow(f)

>>> h = iahistogram(f)

>>> g,d1 = iaplot(h)


>>> g.plot(d1)

>>> nch = MLab.cumsum(h) / (1.*Numeric.product(f.shape))

>>> g,d2 = iaplot(nch)


>>> g.plot(d2)

(f)

0

100

200

300

400

500

600

700

0 50 100 150 200 250 300

(h)

0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

0 50 100 150 200 250 300

(nch)

Use the NCH as intensity transform. ...


>>> gn = (255 * iaapplylut(f, nch)).astype(’b’)

>>> iashow(gn)

>>> gh = iahistogram(gn)

>>> g,d1 = iaplot(gh)


>>> g.plot(d1)

>>> gch = MLab.cumsum(gh) # cumulative histogram

>>> g,d2 = iaplot(gch)


>>> g.plot(d2)

(gn)

0

100

200

300

400

500

600

700

0 50 100 150 200 250 300

(gh)

0

10000

20000

30000

40000

50000

60000

70000

0 50 100 150 200 250 300

(gch)

D.9 iahotellingIllustrate the Hotelling Transform

Image creation. A binary image with an ellipsis

>>> f = iagaussian([100,100], [45,50], [[20,5],[5,10]]) > 0.0000001

>>> iashow(f)

(f)

Feature vector. The coordinates of each 1 pixel are the features: cols and rows coordinates. The meanvalue is the centroid.

>>> import Numeric, MLab

>>> (rows, cols) = iaind2sub(f.shape, Numeric.nonzero(Numeric.ravel(f)))

>>> x = Numeric.concatenate((cols[:,Numeric.NewAxis], rows[:,Numeric.NewAxis]), 1)

>>> mx = MLab.mean(x)

>>> print mx

[50 45]

Computing eigenvalues and eigenvectors. The eigenvalues and eigenvectors are computed fromthe covariance. The eigenvalues are sorted in decrescent order

>>> Cx = MLab.cov(x)

>>> print Cx

[[ 59.31288344 29.65644172]

[ 29.65644172 117.32924335]]

>>> [aval, avec] = MLab.eig(Cx)

>>> aux = Numeric.argsort(aval)[::-1]

>>> aval = MLab.diag(Numeric.take(aval, aux))

>>> print aval

D.9. IAHOTELLING 149

[[ 129.8057478 0. ]

[ 0. 46.83637899]]

>>> avec = Numeric.take(avec, aux)

>>> print avec

[[ 0.38778193 0.92175115]

[-0.92175115 0.38778193]]

Measure the angle of inclination. The direction of the eigenvector of the largest eigenvalue givesthe inclination of the elongated figure

>>> a1 = Numeric.sqrt(aval[0,0])

>>> a2 = Numeric.sqrt(aval[1,1])

>>> vec1 = avec[:,0]

>>> vec2 = avec[:,1]

>>> theta = Numeric.arctan(1.*vec1[1]/vec1[0])*180/Numeric.pi

>>> print ’angle is %3f degrees’ % (theta)

angle is -67.183445 degrees

Plot the eigenvectors and centroid. The eigenvectors are placed at the centroid and scaled by thesquare root of its correspondent eigenvalue

>>> iashow(f)

>>> x_,y_ = iaind2sub(f.shape, Numeric.nonzero(Numeric.ravel(iacontour(f))))

>>> g,d0 = iaplot(y_, 100-x_)

>>> # esboca os autovetores na imagem

>>> x1, y1 = Numeric.arange(mx[0], 100-mx[0]+a1*vec1[0], 0.1), Numeric.arange(mx[1], ←↩mx[1]-a1*vec1[1],0.235)

>>> g,d1 = iaplot(x1, 100-y1) # largest in green

>>> x2, y2 = Numeric.arange(mx[0], mx[0]-a2*vec2[0],-0.1), Numeric.arange(mx[1], mx[1←↩]+a2*vec2[1],0.042)

>>> g,d2 = iaplot(x2, 100-y2) # smaller in blue

>>> g,d3 = iaplot(mx[0], 100-mx[1]) # centroid in magenta

>>> g(’set data style points’)

>>> g(’set xrange [0:100]’)

>>> g(’set yrange [0:100]’)

>>> g.plot(d0, d1, d2, d3)

(f)

0

20

40

60

80

100

0 20 40 60 80 100

(mx)

Compute the Hotelling transform. The Hotelling transform, also called Karhunen-Loeve (K-L)transform, or the method of principal components, is computed below

>>> y = Numeric.transpose(Numeric.matrixmultiply(avec, Numeric.transpose(x-mx)))

>>> my = MLab.mean(y)

>>> print my

[ 6.13287652e-16 -1.10001668e-16]

>>> Cy = MLab.cov(y)

>>> print Cy

[[ 1.29805748e+02 6.15367789e-15]

[ 6.15367789e-15 4.68363790e+01]]

>>> print Numeric.floor(0.5 + Numeric.sqrt(Cy))


[[ 11. 0.]

[ 0. 7.]]

Display the transformed data. The centroid of the transformed data is zero (0,0). To visualize itas an image, the features are translated by the centroid of the original data, so that only therotation effect of the Hotelling transform is visualized.

>>> ytrans = Numeric.floor(0.5 + y + Numeric.resize(mx, (x.shape[0], 2)))

>>> g = Numeric.zeros(f.shape)

>>> i = iasub2ind(f.shape, ytrans[:,1], ytrans[:,0])

>>> Numeric.put(g, i, 1)

>>> iashow(g)

(g)

Image read and display. The RGB color image is read and displayed

>>> f = iaread(’boat.ppm’)

>>> iashow(f)

(f)

Extracting and display RGB components. The color components are stored in the third dimensionof the image array

>>> r = f[:,:,0]

>>> g = f[:,:,1]

>>> b = f[:,:,2]

>>> iashow(r)

>>> iashow(g)

>>> iashow(b)

(r) (g) (b)

Feature vector: R, G and B values. The features are the red, green and blue components. Themean vector is the average color in the image. The eigenvalues and eigenvectors are computed.The dimension of the covariance matrix is 3x3 as there are 3 features in use

>>> x = 1.*Numeric.concatenate((Numeric.ravel(r)[:,Numeric.NewAxis], Numeric.ravel(g)←↩[:,Numeric.NewAxis], Numeric.ravel(b)[:,Numeric.NewAxis]), 1)

>>> mx = MLab.mean(x)

D.9. IAHOTELLING 151

>>> print mx

[ 101.26770732 94.9191999 87.41316573]

>>> Cx = MLab.cov(x)

>>> print Cx

[[ 3497.95108557 3273.20413327 3086.73663437]

[ 3273.20413327 3239.67139072 3103.11181452]

[ 3086.73663437 3103.11181452 3032.39588874]]

>>> [aval, avec] = MLab.eig(Cx)

>>> aux = Numeric.argsort(aval)[::-1]

>>> aval = MLab.diag(Numeric.take(aval, aux))

>>> print aval

[[ 9572.66965395 0. 0. ]

[ 0. 180.2290775 0. ]

[ 0. 0. 17.11963358]]

>>> avec = Numeric.take(avec, aux)

>>> print avec

[[-0.59515464 -0.58010086 -0.55612404]

[ 0.76785348 -0.20637147 -0.60647494]

[ 0.2370485 -0.78796815 0.5682554 ]]

Hotelling transform. The K-L transform is computed. The mean vector is zero and the covariancematrix is decorrelated. We can see the values of the standard deviation of the first, second andthird components

>>> y = Numeric.transpose(Numeric.matrixmultiply(avec, Numeric.transpose(x-mx)))

>>> my = MLab.mean(y)

>>> print my

[ 1.89761523e-13 -1.30753601e-15 -9.03424412e-15]

>>> Cy = MLab.cov(y)

>>> print Cy

[[ 9.57266965e+03 6.47705145e-12 7.30079934e-15]

[ 6.47705145e-12 1.80229077e+02 2.98030617e-13]

[ 7.30079934e-15 2.98030617e-13 1.71196336e+01]]

>>> print Numeric.floor(0.5 + Numeric.sqrt(Cy))

[[ 98. 0. 0.]

[ 0. 13. 0.]

[ 0. 0. 4.]]

Displaying each component of the transformed image. The transformed features are put back inthree different images with the g1 with the first component (larger variance) and g3 with thesmaller variance

>>> g1 = y[:,0]

>>> g2 = y[:,1]

>>> g3 = y[:,2]

>>> g1 = Numeric.reshape(g1, r.shape)



>>> iashow(g1)

>>> iashow(g2)

>>> iashow(g3)


(g1) (g2) (g3)

D.10 iainversefilteringIllustrate the inverse filtering for restoration.

Original and distorted images. The original image is corrupted using a low pass Butterworth fil-ter with cutoff period of 8 pixels and order 4. This has the a similar effect of an out of focus image.


>>> f = iaread(’keyb.pgm’).astype(Numeric.Float)

>>> F = FFT.fft2d(f) # Discrete Fourier Transform of f

>>> H = iabwlp(f.shape, 16, 4) # Butterworth filter, cutoff period 16, order 4

>>> G = F*H # Filtering in frequency domain

>>> g = FFT.inverse_fft2d(G).real # inverse DFT

>>> iashow(ianormalize(g, [0,255])) # display distorted image

(ianormalize(g, [0,255]))

Spectrum of the blurred image and its inverse filter.

>>> iashow(iadftview(G)) # Spectrum of the corrupted image

>>> IH = 1.0/H # The inverse filter

>>> iashow(iadftview(IH)) # Spectrum of the inverse filter

(iadftview(G)) (iadftview(IH))

Applying the inverse filter.

>>> FR = G*IH # Inverse filtering

>>> iashow(iadftview(FR)) # Spectrum of the restored image

>>> fr = FFT.inverse_fft2d(FR).real

>>> iashow(fr) # display the restored image

D.10. IAINVERSEFILTERING 153

(iadftview(FR)) (fr)

Adding a little of noise. The previous example is rather didactical. Just as an experience, insteadof using the corrupted image with pixels values represented in double, we will use a integertruncation to the pixel values.

>>> gfix = Numeric.floor(g) # truncat←↩e pixel values

>>> Gfix = FFT.fft2d(gfix) # DFT of ←↩truncated filted image

>>> FRfix = Gfix * IH # applyin←↩g the inverse filtering

>>> frfix = FFT.inverse_fft2d(FRfix).real

>>> iashow(gfix)

>>> iashow(ianormalize(frfix, [0,255])) # display←↩the restored image

>>> iashow(iadftview(FRfix)) # spectru←↩m of the restored image

(gfix) (ianormalize(frfix, [0,255]))(iadftview(FRfix))

Why is the result so noisy?. When the distorted image is rounded, it is equivalent of subtractinga noise from the distorted image. This noise has uniform distribution with mean 0.5 pixelintensity. The inverted filter is very high pass frequency, and at high frequency, the noiseoutcomes the power of the signal. The result is a magnification of high frequency noise.

>>> import MLab

>>> fn = g - gfix # noise that w←↩as added

>>> print [MLab.mean(Numeric.ravel(fn)), MLab.min(Numeric.ravel(fn)), MLab.max(Numeri←↩c.ravel(fn))] # mean, minumum and maximum values

[0.4994099940305845, 9.2963516067356977e-06, 0.99996062920033069]

>>> iashow(ianormalize(fn, [0,255])) # display nois←↩e

>>> FN = FFT.fft2d(fn)

>>> iashow(iadftview(FN)) # spectrum of ←↩the noise

>>> FNI = FN*IH # inverse filt←↩ering in the noise

>>> fni = FFT.inverse_fft2d(FNI).real

>>> print [MLab.min(Numeric.ravel(fni)), MLab.max(Numeric.ravel(fni))] # min and max ←↩of restored noise

[-15348654.784229765, 15787958.430655854]

>>> iashow(ianormalize(fni, [0,255])) # display rest←↩oration of noise


(ianormalize(fn, [0,255])) (iadftview(FN)) (ianormalize(fni, [0,255]))

D.11 iaitIllustrate the contrast transform function

Identity intensity function. The simplest intensity function is the identify s=v. This transform is aline of 45 degrees. It makes the output image the same as the input image.

>>> import Numeric

>>> f = iaramp([100,100], 10, [0,255])

>>> it = Numeric.arange(256)


>>> iashow(f)

>>> iashow(g)

(f) (g)

Visualizing the intensity transform function. It is common to visualize the intensity transformfunction in a plot, T(v) x v.

>>> g,d = iaplot(it)


>>> g.plot(d)

0

50

100

150

200

250

300

0 50 100 150 200 250 300

(it)

Changing a particular color of an image. To change a given gray scale value v1 of the input imageto another gray scale value s1, we can change the identity function such that T(v1)=s1. Supposewe want to change any pixel with value 0 to 255.

>>> it1 = 1*it

>>> it1[0] = 255

>>> print it1[0:5] # show the start of the intensity table

[255 1 2 3 4]

>>> g = iaapplylut(f, it1)

>>> iashow(g)

D.11. IAIT 155

(g)

Negative of an image. To invert the gray scale of an image, we can apply an intensity transform ofthe form T(v) = 255 - v. This transform will make dark pixels light and light pixels dark.

>>> v = Numeric.arange(255)

>>> Tn = 255 - v


>>> g = iaapplylut(f, Tn)

>>> iashow(g)

>>> g,d = iaplot(Tn)


>>> g.plot(d)

(g)

0

50

100

150

200

250

300

0 50 100 150 200 250 300

(Tn)

Thresholding. A common operation in image processing is called thresholding. It assigns value 1 toall pixels equal or above a threshold value and assigns zero to the others. The threshold operatorconverts a gray scale image into a binary image. It can be easily implemented using the intensitytransform. In the example below the threshold value is 128.


>>> thr = Numeric.concatenate((Numeric.zeros(128), Numeric.ones(128)))

>>> g = iaapplylut(f, thr)

>>> iashow(g)

>>> g,d = iaplot(g)


>>> g.plot(d)

(g)

0

0.2

0.4

0.6

0.8

1

0 10000 20000 30000 40000 50000 60000 70000

(thr)

Threshold band. A variation of the thresholding is when the output is one for a range of the inputgray scale values. In the example below, only pixels between values 100 and 120 are turned toone, the others to zero.

>>> t1 = Numeric.zeros(256)

>>> t1[100:121] = 1

>>> g = iaapplylut(f, t1)

>>> iashow(g)

>>> g,d = iaplot(t1)



>>> g.plot(d)

(g)

0

0.2

0.4

0.6

0.8

1

0 50 100 150 200 250 300

(t1)

Generalized Threshold. A generalization of the previous case is to assign different values (classes) todifferent input ranges. This is a typical classification decision. For pixels from 0 and t1, assign1; from t1 to t2, assign 2, etc. In the example below, the pixels are classified in three categories:class 1: dark pixels (between 0 and 50) corresponding to the cameraman clothing, class 3: mediumgray pixels (from 51 to 180), and class 2: white pixels (from 181 to 255), corresponding to the sky.

>>> t2 = Numeric.zeros(256)

>>> t2[0:51] = 1

>>> t2[51:181] = 3

>>> t2[181:256] = 2

>>> g = iaapplylut(f, t2)

>>> iashow(g)

>>> g,d = iaplot(t2)


>>> g.plot(d)

(g)

1

1.5

2

2.5

3

0 50 100 150 200 250 300

(t2)

Crescent functions. When the intensity transform is a crescent function, if v1 ¿= v1 then T(v1) ¿=T(v2). In this class of intensity transforms, the order of the gray scale does not change, i.e., ifa gray scale value is darker than another in the input image, in the transformed image, it willstill be darker. The intensity order does not change. This particular intensity transforms are ofspecial interest to image enhancing as our visual system does not feel confortable to non-crescentintensity transforms. Note the negation and the generalized threshold examples. The identitytransform is a crescent function with slope 1. If the slope is higher than 1, for a small variationof v, there will be a larger variation in T(v), increasing the contrast around the gray scale v.If the slope is less than 1, the effect is opposite, the constrast around v will be decreased. Alogarithm function has a higher slope at its beginning and lower slope at its end. It is normallyused to increase the contrast of dark areas of the image.

>>> v = Numeric.arange(256)

>>> Tlog = (256./Numeric.log(256.)) * Numeric.log(v + 1)

>>> f = ianormalize(iaread(’lenina.pgm’), [0, 255])

>>> g = iaapplylut(f.astype(’b’), Tlog)

>>> iashow(f)

>>> iashow(g)

>>> g,d = iaplot(Tlog)


>>> g.plot(d)

D.12. IAMAGNIFY 157

(f) (g)

0

50

100

150

200

250

300

0 50 100 150 200 250 300

(Tlog)

Normalization function. Sometimes the input image has ranges in floating point or ranges notsuitable for displaying or processing. The normalization function is used to fit the range ofthe gray scales, preserving the linear gray scale relationship of the input image. The intensityfunction that provides the normalization is a straight line segment which can be defined by itstwo extremities. Suppose the input gray scales ranges from m1 to m2 and we want to normalizethe image to the range of M1 to M2. The two extremities points are (m1,M1) and (m2,M2).The equation for the intensity normalization function is point-slope form of the line equation:T(v) - M1 =(M2-M1)/(m2-m1)*(v - m1). The function ianormalize does that.

D.12 iamagnifyIllustrate the interpolation of magnified images

Reading and ROI selection. The image is read and a 64x64 ROI is selected and displayed

>>> fin = iaread(’lenina.pgm’)

>>> iashow(fin)

>>> froi = fin[137:137+64,157:157+64]

>>> iashow(froi)

>>> print froi.shape

(64, 64)

(fin) (froi)

DFT. The DFT of the small image is taken and its spectrum displayed



>>> F = FFT.fft2d(fd)

>>> iashow(froi)


(froi) (iadftview(F))

Expansion by 4 without interpolation. The image is expanded by 4, but filling the new pixels with 0


>>> fx4 = Numeric.zeros(4*Numeric.array(froi.shape))

>>> fx4[::4,::4] = froi

>>> iashow(froi)

>>> iashow(fx4)

(froi) (fx4)

DFT of the expansion without interpolation. Using the expansion propertie of the DFT (onlyvalid for the discrete case), the resulting DFT is a periodical replication of the original DFT.

>>> fdx4 = fx4.astype(Numeric.Float)

>>> Fx4 = FFT.fft2d(fdx4)

>>> iashow(fx4)

>>> iashow(iadftview(Fx4))

(fx4) (iadftview(Fx4))

Filtering by mean filtering - nearest neighbor. Filtering the expanded image using an averagefilter of size 4x4 is equivalent of applying a nearest neighbor interpolator. The zero pixels arereplaced by the nearest non-zero pixel. This is equivalent to interpolation by pixel replication.

>>> k = Numeric.ones((4,4))

>>> fx4nn = iapconv(fdx4, k)

>>> iashow(fx4)

>>> iashow(fx4nn.astype(Numeric.Int))

(fx4) (fx4nn.astype(Numeric.Int))

Interpretation of the mean filtering in the frequency domain. Filtering by the average filter inspace domain is equivalent to filter in the frequency domain by the sync filter.

>>> kzero = Numeric.zeros(fx4.shape)

>>> kzero[0:4,0:4] = k

>>> K = FFT.fft2d(kzero)

>>> iashow(iadftview(K))

>>> Fx4nn = K * Fx4

>>> iashow(iadftview(Fx4nn))

D.12. IAMAGNIFY 159

(iadftview(K)) (iadftview(Fx4nn))

Filtering by pyramidal kernel, linear interpolation. Filtering by a pyramidal kernel in spacedomain is equivalent to make a bi-linear interpolation. The zero pixels are replaced by a weightedsum of the neighbor pixels, the weight is inversely proportional to the non-zero pixel distance.

>>> klinear = Numeric.array([1,2,3,4,3,2,1])/4.

>>> k2dlinear = Numeric.matrixmultiply(Numeric.reshape(klinear, (7,1)), Numeric.resha←↩pe(klinear, (1,7)))

>>> fx4li = iapconv(fdx4, k2dlinear)

>>> iashow(fx4)

>>> iashow(fx4li.astype(Numeric.Int))

(fx4) (fx4li.astype(Numeric.Int))

Interpretation of the pyramid filtering in the frequency domain. Filtering by the pyramidfilter in space domain is equivalent to filter in the frequency domain by the square of the sync filter.

>>> klizero = Numeric.zeros(fx4.shape).astype(Numeric.Float)

>>> klizero[0:7,0:7] = k2dlinear

>>> Klinear = FFT.fft2d(klizero)

>>> iashow(iadftview(Klinear))

>>> Fx4li = Klinear * Fx4

>>> iashow(iadftview(Fx4li))

(iadftview(Klinear)) (iadftview(Fx4li))

Using an ideal filter. Filtering by cutoff period of 8

>>> H8 = iabwlp(fx4.shape, 8, 10000)

>>> iashow(iadftview(H8))

>>> G8 = Fx4 * H8

>>> iashow(iadftview(G8))

>>> g_ideal = FFT.inverse_fft2d(G8)

>>> print max(Numeric.ravel(g_ideal.imag))

3.02612295926e-14

>>> g_ideal = ianormalize(g_ideal.real, [0,255])

>>> iashow(g_ideal)


(iadftview(H8)) (iadftview(G8)) (g_ideal)

Using a Butterworth filter of order 5. Filtering by cutoff period of 8

>>> HB8 = iabwlp(fx4.shape, 8, 5)

>>> iashow(iadftview(HB8))

>>> GB = Fx4 * HB8

>>> iashow(iadftview(GB))

>>> g_b = FFT.inverse_fft2d(GB)

>>> print max(Numeric.ravel(g_b).imag)

3.21183896607e-14

>>> g_b = ianormalize(g_b.real, [0,255])

>>> iashow(g_b)

(iadftview(HB8)) (iadftview(GB)) (g_b)

Display all four for comparison. Top-left: nearest neighbor, Top-right: linear, Bottom-left: ideal,Bottom-right: Butterworth

>>> aux1 = Numeric.concatenate((fx4nn[0:256,0:256], fx4li[0:256,0:256]), 1)

>>> aux2 = Numeric.concatenate((g_ideal, g_b), 1)

>>> iashow(Numeric.concatenate((aux1, aux2)))

(Numeric.concatenate((aux1, aux2)))

D.13 iaotsudemoIllustrate the Otsu Thresholding Selection Method

Image read and histograming. Gray scale image and its histogram

>>> import Numeric

>>> f = iaread(’woodlog.pgm’);

>>> iashow(f)

>>> H = iahistogram(f)

>>> x = Numeric.arange(len(H))

>>> k = x[0:-1]

>>> g,d = iaplot(x, H)

D.13. IAOTSUDEMO 161

(f)

0

100

200

300

400

500

600

700

0 50 100 150 200 250 300

(H)

Normalized histogram. If the histogram is divided by the number of pixels in the image, it can beseen as a probability distribution. The sum of each values gives one. The mean gray level can becomputed from the normalized histogram.

>>> import MLab

>>> h = 1.*H/Numeric.product(f.shape)

>>> print Numeric.sum(h)

1.0

>>> mt = Numeric.sum(x * h)

>>> st2 = Numeric.sum((x-mt)**2 * h)

>>> if abs(mt - MLab.mean(Numeric.ravel(f))) > 0.01: iaerror(’error in computing mean←↩’)

error in computing mean

>>> if abs(st2 - MLab.std(Numeric.ravel(f))**2) > 0.0001: iaerror(’error in computing←↩var’)

error in computing var

>>> print ’mean is %2.2f, var2 is %2.2f’ % (mt, st2)

mean is 91.03, var2 is 2873.86

>>> maux = 0 * h

>>> maux[int(mt)] = max(h)

>>> g,d1 = iaplot(x,h)

>>> g,d2 = iaplot(x,maux)

>>> g.plot(d1, d2)

0

0.001

0.002

0.003

0.004

0.005

0.006

0.007

0.008

0.009

0.01

0 50 100 150 200 250 300

(h)

Two classes. Suppose the pixels are categorized in two classes: smaller or equal than the gray scale tand larger than t. The probability of the first class occurrence is the cummulative normalizedhistogram. The other class is the complementary class.

>>> w0 = MLab.cumsum(h[0:-1])

>>> aux = h[1::]

>>> w1aux = MLab.cumsum(aux[::-1])[::-1]

>>> w1 = 1 - w0

>>> if max(abs(w1-w1aux)) > 0.0001: iaerror(’error in computing w1’)

>>> g,d1 = iaplot(k,w0)

>>> g,d2 = iaplot(k,w1)

>>> g.plot(d1, d2)


0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

0 50 100 150 200 250 300

(w0,w1)

Mean gray level of each class. The mean gray level as a function of the thresholding t is computedand displayed below.

>>> m0 = MLab.cumsum(k * h[0:-1]) / (1.*w0)

>>> m1 = (mt - m0*w0)/w1

>>> aux = (k+1) * h[1::]

>>> m1x = MLab.cumsum(aux[::-1])[::-1] / (1.*w1)

>>> mm = w0 * m0 + w1 * m1

>>> if max(abs(m1-m1x)) > 0.0001: iaerror(’error in computing m1’)

>>> g,d1 = iaplot(k,m0)

>>> g,d2 = iaplot(k,m1)

>>> g,d3 = iaplot(k,mm)

>>> g.plot(d1,d2,d3)

0

50

100

150

200

250

300

0 50 100 150 200 250 300

(m0,m1)

Variance of each class. The gray level variance as a function of the thresholding t is computed anddisplayed below.

>>> s02 = MLab.cumsum((k-m0)**2 * h[0:-1]) / (1.*w0)

>>> aux = ((k+1)-m1)**2 * h[1::]

>>> s12 = MLab.cumsum(aux[::-1])[::-1] / (1.*w1)

>>> g,d1 = iaplot(k, s02)


>>> g.plot(d1, d2)

0

500

1000

1500

2000

2500

3000

0 50 100 150 200 250 300

(s02)

Class separability. The variance between class is a good measure of class separability. As higher thisvariance, the better the class clustering.

>>> sB2 = w0 * ((m0 - mt)**2) + w1 * ((m1 - mt)**2)

>>> sBaux2 = w0 * w1 * ((m0 - m1)**2)

>>> if max(sB2-sBaux2) > 0.0001: iaerror(’error in computing sB’)

>>> v = max(sB2)

>>> t = (sB2.tolist()).index(v)

>>> eta = 1.*sBaux2[t]/st2

D.13. IAOTSUDEMO 163

>>> print ’Optimum threshold at %f quality factor %f’ % (t, eta)

Optimum threshold at 93.000000 quality factor 0.694320

>>> g,d1 = iaplot(k, sB2)

>>> g,d2 = iaplot(k, H[0:-1])



>>> g.plot(d1, d2, d3, d4)

0

500

1000

1500

2000

2500

3000

0 50 100 150 200 250 300

(sB)

Thresholding. The thresholded image is displayed to illustrate the result of the binarization using theOtsu method.

>>> x_ = iashow(f > t)

(f > t)

ambiente de suporte ao ensino de processamento de imagens …alexgs/tese/silva.pdf · a linguagem...

Documents