spring código aberto · e herdam o seu sistema de projeção cartográfica. os dados originais...
TRANSCRIPT
Desenvolvendo Ferramentas com o SPRING
Versão Windows, Linux e MAC
SPRING Código Aberto
Setembro de 2017 INPE
As informações contidas neste documento estão sujeitas a alterações e correções sem
prévio aviso. Esse documento pode ser utilizado para reprodução direta ou geração de
produtos derivados, desde que seja ressalvado o direito de propriedade intelectual do
INPE, através de declaração explícita no texto.
Sugestões ou correções podem ser enviadas através do endereço eletrônico:
INSTITUTO NACIONAL DE PESQUISAS ESPACIAIS
Exemplos de Funcionalidades
SPRING Código Aberto ............................................................................................................................................ 3
Definições da Arquitetura ......................................................................................................................................... 4
Modelo Conceitual.................................................................................................................................................. 4
Banco de Dados ....................................................................................................................................................... 5
Estrutura ................................................................................................................................................................ 5
Arquivos ................................................................................................................................................................ 7
Diretório do código fonte ...................................................................................................................................... 8
Ambiente de Desenvolvimento .............................................................................................................................. 10
Pré-requisitos .......................................................................................................................................................... 10
Compiladores ......................................................................................................................................................... 10
Gerenciamento de Janelas .................................................................................................................................. 10
Banco de Dados ..................................................................................................................................................... 12
Formatos de Arquivos .......................................................................................................................................... 12
Geo estatística ........................................................................................................................................................ 12
Compilando os aplicativos SPRING ............................................................................................................... 13
Ajustando os parâmetros ................................................................................................................................ 13
Compilar ............................................................................................................................................................. 15
Classes e Variáveis .................................................................................................................................................... 17
Classes ...................................................................................................................................................................... 17
Variáveis .................................................................................................................................................................. 22
Exemplos de Funcionalidades ................................................................................................................................ 23
Transformada Rápida de Fourier ...................................................................................................................... 23
SPRING Código Aberto
Este documento apresenta as características de arquitetura global, as definições da
estrutura de diretório, as necessidades e os procedimentos indispensáveis para a montagem do
ambiente de desenvolvimento, a compilação do conjunto de aplicativos SPRING.
Além disso, este documento demonstra a documentação básica de algumas classes e
variáveis junto com um exemplo de funcionalidade no qual se utilizará de algumas dessas classes
e variáveis apresentadas.
Exemplos de Funcionalidades
Definições da Arquitetura
Neste capítulo abordamos as definições do sistema, no qual apresentamos o modelo
conceitual, a estrutura do banco de dados, as descrições dos tipos de arquivos, a estrutura de
diretórios do código fonte.
Modelo Conceitual
O SPRING contém um modelo conceitual próprio de informações geográficas e através desse
modelo que os usuários manipulam e trabalham seus dados com os algoritmos implementados no
pacote de aplicativos SPRING. As entidades que formam o modelo conceitual são:
• Banco de Dados
Representa um repositório de informações que contém o modelo de organização dos dados
armazenados em SGDB's – Sistemas Gerenciadores de Banco de Dados – e inclui as informações
geográficas em arquivos locais.
• Projeto
Representa um conjunto de informações geográficas dentro de um retângulo envolvente definido
e herdam o seu sistema de projeção cartográfica. Os dados originais provenientes de outros
sistemas de projeção, serão sempre remapeados para a projeção do projeto durante o processo de
importação ou entrada de dados.
Por isso a importância de se definir um sistema adequado com a escala dos dados, prevendo-se
também os produtos cartográficos que serão gerados.
Um projeto corresponde fisicamente a um subdiretório debaixo do diretório do banco de dados ao
qual pertence.
• Projeção Cartográfica
Representa a referência geográfica da componente espacial das informações geográficas. As
projeções permitem projetar a superfície terrestre em uma superfície plana. Diferentes projeções
são utilizadas para minimizar as diferentes deformações inerentes ao processo de projeção de um
elipsóide em um plano.
• Retângulo Envolvente
Define uma área limite no qual apenas as informações geográficas consideradas serão as áreas internas
ao retângulo envolvente. Dados geográficos com limites maiores que a área do projeto serão limitados
pelas coordenadas do projeto no momento da importação ou da entrada dos dados.
• Modelo de Dados
Agrupa dados de mesma natureza no banco de dados, definindo uma categoria de dados. Cada
Exemplos de Funcionalidades
categoria é sempre associada a um único modelo de dados e poderá conter inúmeros Planos de
Informações em diferentes projetos no mesmo Banco de Dados. Apenas após a criação das
Categorias será possível a criação de Planos de Informações. No caso do modelo de dados Não-
Espacial o nome da tabela deve ser fornecido obrigatoriamente.
• Plano de Informação
Representa uma estrutura de agregação de um conjunto de informações espaciais que são
localizadas sobre uma região geográfica e compartilham um conjunto de atributos, ou seja, plano
de informação agrega coisas semelhantes. Como exemplos de plano de informação podem ser
citados os mapas temáticos, mapas cadastrais de objetos geográficos ou dados matriciais como
cenas de imagens de satélites ou aéreas.
• Representações
Simboliza o modelo de representação da componente espacial dos dados geográficos e
basicamente pode ser do tipo vetorial ou matricial. A representação vetorial são representações
formadas por pontos, linhas e áreas, mas essas representações podem ser ainda mais específicas
como amostras, isolinhas, linhas, tin, etc. A representação matricial são grades regulares
unidimensionais que podem ser de diversos tipos como imagem (pode ser combinada formando
uma imagem multi espectral), imagem sintética, imagem classificada, grades numéricas
(altimetria, batimetria, temperatura e outros) e matriz temática.
• Visual
Representa um conjunto de características de apresentação de primitivas geográficas. Por
exemplo, cores de preenchimento dos polígonos, espessura das linhas, cores dos pontos,
símbolos de pontos, estilos de linhas, etc.
Banco de Dados
O banco de dados do SPRING possui uma característica dual, uma parte do banco de dados
fica armazenado em um banco de dados no qual é responsável por armazenar e manipular as
informações globais do sistema como projetos, categorias, planos de informação, visual de
apresentação, coleções, tabelas de objetos e não espacial e outras informações.
A outra parte fica em arquivos locais no qual nesses arquivos armazenam as informações
das representações dos planos de informação, como por exemplo pontos, linhas, imagens,
polígonos e as demais representações.
Estrutura
Abaixo apresentamos os nomes e uma pequena descrição das tabelas que formam o banco
de dados do aplicativo SPRING.
• category
Exemplos de Funcionalidades
◦ Esta tabela armazena todas as categorias e classes criadas para um banco
de dados qualquer.
• NextIds5
◦ Esta tabela é um "contador" interno ao SPRING que controla a geração de
identificadores de qualquer elemento introduzido ao banco de dados. São
identificadores do próximo item que será criado.
• projecti
◦ Esta tabela contém as projeções (Projeção cartográfica e demais parâmetros
fornecidos pelo usuário) definidos para projetos presentes no banco de
dados.
• projects
◦ Esta tabela possui as características dos projetos do banco de dados.
• repres
◦ Esta tabela armazena as representações associadas a um plano de
informação.
• visual
◦ Esta tabela armazena o visual de apresentação dos dados do SPRING (Plano
de Informação, Classe Temática, Objeto, Amostras).
• infolaye
◦ Esta tabela armazena as definições de um plano de informação.
• GA000XXX
◦ Tabela e arquivo index das âncoras, onde 000XXX é o id da representação
na tabela repres. Esta tabela só é criada no momento que um objeto for
associado a uma representação gráfica em algum plano de informação do
modelo cadastral ou redes.
• OJ000XXX
◦ Tabelas dos objetos geográficos existentes em todo banco de dados, onde
000XXX é o id da categoria do objeto. Esta tabela só é criada no momento
que passar a existir um objeto em um projeto.
• CG000XXX
◦ Tabelas criados automaticamente pelo sistema, onde 000XXX é o id da
categoria do objeto. Estas tabelas são utilizadas pelo usuário para definir os
atributos alfanuméricos dos objetos.
• vgclass
◦ Esta tabela armazena a visibilidade das classes dos planos de informação. [email protected] 6
Exemplos de Funcionalidades
• collections
◦ Esta tabela armazena as coleções geradas no sistema.
• pictures
◦ Tabelas com as imagens, documentos, vídeos, etc associadas ao banco de
dados.
• metadata
◦ Esta tabela armazena os metadados de algumas informações da estrutura
do banco de dados.
• linktable
◦ Esta tabela armazena as ligações entre as tabelas de objetos e a tabela não
espacial.
• filevers
◦ Esta tabela armazena as versões dos formatos de arquivos.
Arquivos
Abaixo apresentamos as descrição genérica de cada um destes arquivos de representações
• Linhas
◦ *.lin – Armazena o cabeçalho das linhas
◦ *.blk – Armazena os blocos com os pontos que formam as linhas
◦ *.rtl - Armazena a estrutura da árvore de indexação das linhas
• Pontos
◦ *.p2d - Armazena as informações de pontos de planos de informação das
categorias temático e cadastral
◦ *.p3d - Armazena as informações de pontos de planos de informação da
categoria numérica
◦ *.kdt - Armazena a estrutura da árvore de indexação dos pontos
• Nós
◦ *.no1 – Armazena o cabeçalho e as informações dos nós
◦ *.no2 - Armazena a lista das linhas conectadas ao nó
• Polígonos
◦ *.po1 - Armazena o cabeçalho e algumas informações dos polígonos
◦ *.po2 – Armazena as lista que formam o polígono e a lista dos polígonos filhos
Exemplos de Funcionalidades
◦ *.rtp - Armazena a estrutura da árvore de indexação dos polígonos
• Âncoras
◦ *.an1 – Armazena o cabeçalho e informações das âncoras
◦ *.an2 – Armazena a lista de identificadores dos pontos, linhas e polígonos
associados
◦ *.rta – Armazena a estrutura da árvore de indexação das âncoras
• Textos
◦ *.itx - Armazena o identificador do texto
◦ *.txt – Armazena as informações do texto
◦ *.kde – Armazena a estrutura da árvore de indexação dos textos
• Imagens
◦ *.lut – Armazena os índices com os valores em RGB de imagens sintéticas e
classificadas ou as faixas de valores para visualização da grade como uma
imagem
◦ *.thm – Armazena os temas (código, valores RGB e nome) de uma imagem
classificada
◦ *.reg – Armazena os segmentos da imagem rotulada
◦ *.spg – Armazena valores de ponto de grade expresso no modo binário
◦ *.dsc – Armazena a descrição dos dados representados no arquivo spg, as
informações contidas nesse arquivo são variáveis, dependem do tipo de
imagem e processamento aplicados à esta
• Restrição
◦ *.turn – Armazena as informações dos arcos que possuem a restrição de direção
Diretório do código fonte
O SPRING possui uma estrutura de diretório bem definida e abaixo apresentamos a
estrutura base e alguns arquivos ou diretórios importantes:
• projetos – Contém os arquivos referente a geração dos projetos, cada pasta é
responsável pela definição de um projeto
• src – Contém o código fonte necessário para a compilação do pacote SPRING
• distribuicao – Diretório no qual é gerado as bibliotecas e aplicativos do pacote
SPRING na plataforma 32 bits
Exemplos de Funcionalidades
◦ linuxtargz.lua – Script de geração de distribuições Linux
◦ helpport – Contém os arquivos do Ajuda Online em português
◦ helpeng – Contém os arquivos do Ajuda Online em inglês
◦ helpspa – Contém os arquivos do Ajuda Online em espanhol
◦ versao – Contém arquivos necessários na distribuição do SPRING
▪ script-nsis-windows.nsi – Script básico para geração de instaladores
▪ springdb50 – Exemplo de banco de dados SPRING
◦ bitmaps e etc – Contém arquivos necessários para execução do SPRING
• distribuicaox64 – Diretório no qual é gerado as bibliotecas e aplicativos do
pacote SPRING na plataforma 64 bits
• Arquivos para o MAC • macos-configs.sh – responsável por armazenar as variáveis de configurações para
o ambiente macOS • macos-generate-dependencies.sh – responsável por baixar as dependências
(compiladas como GCC, gFortran e MySQL e compilar a Terralib 5) • macos-generate-bundle.sh – Gera o bundle final, e os instaladores para os 4 idiomas do Spring • macos-rpath-fix.py – arquivo utilizado no processo de criação do bundle, faz a correção dinâmica de RPATH de libs, frameworks e executáveis • macos-uninstall-deps.sh – Responsável pela remoção das dependências instaladas na raiz do sistema como GCC, gFortran e MySQL • Info.plist – Responsável por definir configurações como ícone e nome da aplicação que irá aparecer no dock do macOS
Exemplos de Funcionalidades
Ambiente de Desenvolvimento
Pré-requisitos
Algumas bibliotecas são requisitadas para a compilação do conjunto de aplicativos SPRING.
Essas dependências são principalmente bibliotecas de gerenciamento das janelas (Qt), banco de
dados (MySQL, PostgreSQL, Oracle) e formatos de arquivos (TIFF, JPEG, JPEG2000, GPS, SHAPEFILE,
DXF).
O SPRING contém algumas dessas bibliotecas externas em seu código fonte, mas ainda há
bibliotecas que são necessárias realizar o download e instalar.
Compiladores
Os compiladores testados para compilar o conjunto de aplicativos SPRING são:
• Ambiente Windows:
◦ Visual Studio 2013
▪ A versão Express, a mais simples, pode ser obtido gratuitamente no sitio
http://www.microsoft.com/exPress/
• Ambiente Linux
◦ GCC / G++
▪ Normalmente esse compilador já vem instalado nas distribuições Linux
• Ambiente Mac
◦ Xcode
▪ É obtido através da App Store
▪ O compilador utilizado é Apple LLVM
Gerenciamento de Janelas
Para os ambientes Windows/Linux/MAC é necessário a instalação do Framework Qt
responsável principalmente pelo gerenciamento das janelas. O Qt é disponibilizado pela Nokia e
possui uma licença livre e pode ser obtido no sitio de internet http://qt.nokia.com/.
Uma necessidade da biblioteca Qt é a compilação da mesma de forma estática e com suporte
OpenGL. Abaixo uma demostração da compilação da biblioteca Qt. Esse passo é bem demorado.
• Descompacte o arquivo baixado (qt-win-opensource-src-<versão>.zip)
• Abra um Prompt de Comando(Windows) ou Terminal(Linux/MAC) que contenha
as informações do compilador (Ex: Visual Studio 2013 Command Prompt)
• Entre no diretório, em que o Qt foi extraído [email protected] 10
Exemplos de Funcionalidades
◦ cd c:\Qt\qt-win-opensource-src-5.8
• Windows
◦ Execute o comando configure e siga os passos para configurar a biblioteca
do Qt
▪ configure
◦ Após configurado, compile e instale a biblioteca com o seguinte comando
▪ Visual Studio 2013
•nmake install
• Linux
◦ A compilação do Qt no ambiente Linux é um pouco mais complicada, é
necessário instalar uma série de bibliotecas antes de configurar a geração
do Qt. As bibliotecas são:
▪ OpenGl (mesa-libglu-devel)
▪ LibXext (libXext-devel)
▪ LibXinerama (libXinerama-devel)
▪ LibXcursor (libXcursor-devel)
▪ LibXfixes (libXfixes-devel)
▪ LibXrandr (libXrandr-devel)
▪ LibXrender (libXrender-devel)
▪ LibXi (libXi-devel)
▪ FontConfig (fontconfig-devel)
▪ LibJpeg (libjpeg-devel)
além das bibliotecas as suas dependências também precisam ser instaladas. Os nomes das
bibliotecas podem variar de acordo com a distribuição Linux.
Utilize o aplicativo “Instalar e Remover Programas” da distribuição Linux para instalar as
bibliotecas requisitadas pelo Qt.
◦ Execute o comando configure e siga os passos para configurar a biblioteca
do Qt
▪ configure
• Durante a configuração do Qt é apresentado uma lista de bibliotecas
que o Qt utilizará. Verifique se as bibliotecas citadas acima estão
com valores diferente de “no”.
◦ Após configurado, compile e instale a biblioteca com o seguinte comando
Exemplos de Funcionalidades
▪ GCC / G++
•sudo make install
• Pronto Qt, compilado e instalado
Banco de Dados
Para o ambiente Windows não é necessário instalar as bibliotecas dos bancos de dados, as
mesmas já se encontram no código fonte do SPRING, mas no ambiente Linux é necessário instalar
o pacote de desenvolvimento do MySQL e PostgreSQL.
As bibliotecas de banco de dados necessárias no ambiente Linux são mysql-devel e
postgresql-devel. Cada ambiente Linux possui uma maneira para instalar essas bibliotecas, utilize
a que melhor se adéqüe a sua distribuição Linux. Abaixo uma demostração de instalação no
ambiente Ubuntu e OpenSuse.
• Instalando as bibliotecas no Ubuntu 16.04
◦ apt-get install libmysqlclient16-dev
◦ apt-get install libpq-dev
• Instalando as bibliotecas no OpenSuse 11
◦ yast2 --install libmysqlclient-devel
◦ yast2 --install postgresql-devel
Formatos de Arquivos
No ambiente Linux é necessário ainda instalar a biblioteca de acesso USB, utilizada na
importação de dados via GPS. A biblioteca é “libusb-dev” e abaixo uma demostração da instalação
da mesma no ambiente Ubuntu e OpenSuse.
• Instalando as bibliotecas no Ubuntu 16.04
◦ apt-get install libusb-dev
• Instalando as bibliotecas no OpenSuse 11
◦ yast2 --install libusb-compat-devel
Geo estatística
Caso precise utilizar o módulo de geoestatística no ambiente Linux é necessário instalar o
compilador FORTRAN compatível com pacote de geoestatística. Para instalar o IFORT (compilador
Exemplos de Funcionalidades
desenvolvido pela INTEL), faça o download do mesmo no sitio de internet
http://software.intel.com/en-us/articles/non-commercial-software-download/ e escolha a opção
“Intel® Fortran Compiler Professional Edition for Linux” e siga os passos para fazer o download e
obter uma licença gratuita para o ifort.
Após realizar o download, faça os seguintes passos:
• descompacte o arquivo baixado
◦ tar -zxf l_cprof_p_11.0.081_ia32.tar.gz
• instale o compilador fortran
◦ cd l_cprof_p_11.0.081_ia32
◦ ./install.sh
◦ responda as questões da instalação e siga os passos requisitados
• adicione o ifort ao diretório /usr/bin, necessário logar como root
◦ su – digite a senha de root
◦ ln -sf /opt/intel/Compiler/11.0/081/bin/ia32/ifort /usr/bin/ifort
Compilando os aplicativos SPRING
Ajustando os parâmetros
Antes de tudo, é necessário ajustar alguns parâmetros para a compilação do pacote
SPRING. Esses parâmetros definem o ambiente de compilação (Windows ou Linux), a plataforma de
compilação (32 ou 64 bits), os caminhos das bibliotecas externas e outras definições.
Escolha o ambiente e a plataforma de compilação
• Edite o arquivo projetos/springplataform.pri
◦ Selecione a plataforma através da variável SPRINGPLATAFORM, os valores
possíveis são 32 ou 64
▪ Exemplo: SPRINGPLATAFORM = 32
◦ Selecione o ambiente através da variável SPRINGOPERATIONALS, os valores
possíveis são SPRING_WINDOWS, SPRING_LINUX ou SPRING_MACOS.
▪ Exemplo: SPRINGOPERATIONALS = SPRING_WINDOWS
No caso em que o ambiente de compilação é Linux, é necessário definir o caminho das
bibliotecas MySQL e PostgreSQL. Para isso faça os seguintes passos
• Edite o arquivo projetos/defaultdefines.pri
◦ A variável SPRING_MYSQL_INCLUDE indica o caminho dos arquivos que
constituem a biblioteca MySQL. Modifique essa variável de acordo com a [email protected] 13
Exemplos de Funcionalidades
instalação realizada
▪ Exemplo: SPRING_MYSQL_INCLUDE = /usr/include/mysql
◦ A variável SPRING_POSTGRESQL_INCLUDE indica o caminho dos arquivos que
constituem a biblioteca PostgreSQL. Modifique essa variável de acordo com
a instalação realizada
▪ Exemplo: SPRING_POSTGRESQL_INCLUDE = /usr/include/pgsql
Exemplos de Funcionalidades
Compilar
Após os ajustes realizados, vamos compilar o pacote SPRING de aplicativos. Cada
compilador possui uma característica própria, logo iremos apresentar a compilação em cada
compilador testado para os aplicativos SPRING.
GERAÇÃO DOS PROJETOS
Um passo anterior a compilação é a geração dos projetos, nessa etapa que criamos os
arquivos que de fato gerenciam a compilação das bibliotecas e aplicativos. Cada compilador se
utiliza de um tipo de arquivos para compilar os projetos, o Visual Studio utiliza os arquivos “.sln” e
“.vcproj”, enquanto o GCC/G++ utiliza o arquivo Makefile.
Para gerar os arquivos de projetos, utilizamos a ferramenta qmake, do framework Qt, no
qual essa ferramenta cria automaticamente esses diversos tipos de projetos dado a configuração
definida. Abaixo seguem os passos para gerar os arquivos de projetos do SPRING.
• Abra um Prompt de Comando(Windows) ou Terminal(Linux ou MAC)
• Defina na variável QTDIR o diretório de instalação do framework Qt
◦ Windows
▪ set QTDIR=C:\Qt\Qt5.8.0
◦ Linux
▪ export QTDIR=/usr/local/TrollTech/Qt-<versão>
◦ MAC
▪ No MAC não é necessário, pois essas configurações serão realizadas no
script seguinte.
• Defina o tipo de arquivo de projetos
◦ Windows Visual Studio
Exemplos de Funcionalidades
▪ set QMAKESPEC=win32-msvc2013
◦ Linux
▪ export QMAKESPEC=linux-g++
◦ MAC
Execute o script com: source ./macos-configs.sh
Esses passos estão exemplificados nos arquivos <vscmd-32-qt.bat>(Windows)
• Gerando os arquivos de projetos
◦ Windows e compilador Visual Studio
▪ Execute o script gerarvcproj.bat
◦ Linux
▪ Execute o script ./gerarmakefile.sh
◦ MAC
Execute o script $QT_BINARIES/qmake -makefile -recursive projetos.pro
Após esses passos o SPRING está pronto para ser compilado, para isso faça
• Windows Visual Studio
◦ Abra o arquivo projetos/projetos.sln
◦ Escolha entre a configuração Debug ou Release
◦ Dê um build nos projetos
◦ Execute o SPRING ou SPR2TLIB
• Linux GCC/G++
◦ Execute o comando make
• MAC GCC/G++ no Apple LLVM
◦ Execute o comando make
Os possíveis erros de compilação estarão relacionados aos caminhos das bibliotecas de banco de
dados MySQL ou PostgreSQL.
◦ Execute o SPRING ou SPR2TLIB Para executar os
aplicativos SPRING, execute o seguinte comando
▪ Linux 32 Bits
• export
LD_LIBRARY_PATH=”<diretorio_absoluto_spring>/distribuicao;<diretori
o_absoluto_spring>/src/terralib/terralibx/Oracle”
▪ Linux 64 Bits
• export
LD_LIBRARY_PATH=”<diretorio_absoluto_spring>/distribuicao;<diretori
o_absoluto_spring>/src/lib/oracleocci/libocci64”
Exemplos de Funcionalidades
Classes e Variáveis
Neste capítulo apresentaremos algumas classes e variáveis necessárias para a criação de
novas funcionalidades. Através dessas classes e variáveis será possível a manipulação de planos
de informação, categorias, dados e qualquer outra informação do SPRING.
Além desta descrição, a documentação das classes do SPRING estão divulgadas no sitio de
internet (www.spring-gis.org/doc), no qual contém toda a documentação de classes do SPRING.
Classes
• Database
Esta classe base define os protótipos para o acesso e manipulação do banco de dados
SPRING. A partir dessa classe que são criados os drivers dos banco de dados (SQLite,
MySQL, PostgreSQL, Oracle, Access).
Alguns métodos desta classe são:
Activate – Ativa o banco de dados
Create – Cria um banco de dados
CreateCategory – Cria uma categoria
DataHome – Retorna o diretório do banco de dados
Deactivate – Desativa o banco de dados
GetProject – Retorna a lista de projetos
GetSpringCategory – Retorna a lista de categoria, menos a de objetos e não espacial
GetSpringObjCategory – Retorna a lista de categoria de objetos e não espacial
LoadCategory – Carrega a lista de categorias
LoadInfoLayer – Carrega um plano de informação dado alguns parâmetros
LoadProject - Carrega um projeto dado alguns parâmetros
NewProject – Cria um novo projeto
NewInfoLayer – Cria um novo plano de informação
Select – Retorna a lista de banco de dados de um diretório
• Project
Esta classe define a área geográfica do estudo, a projeção e o diretório no qual os dados
são armazenados.
Alguns métodos desta classe são:
Exemplos de Funcionalidades
BoundingBox – Retorna o retângulo envolvente do projeto
GetInfoLayerList – Retorna a lista de planos de informação associadas ao projeto
Init – Inicializa o projeto
Insert – Insere um plano de informação ao projeto
LLBox - Retorna o retângulo envolvente do projeto em coordenadas geográficas
Projection – Retorna à projeção do projeto
Show – Desenha os planos de informações visíveis do projeto na área de desenho
passada como parâmetro
• Projections
Esta classe específica o modelo da terra (Datum) e os parâmetros das projeções que
representam uma superfície comum em termos de projeção de mapas convencionais.
As projeções implementadas no SPRING em ordem alfabética são: Albers, Bipolar,
CylinEquid, Gauss, General Lambert, Lambert, Lambert Million, LatLong, Mercator,
Miller, PolarStereo, Polyconic, Satellite, Sanosoidal e Utm.
Alguns métodos desta classe são:
Init – Inicializa uma projeção
LL2PC – Transforma coordenadas geodéticas (radiano) em coordenadas da
projeção(metros)
PC2LL – Transforma coordenadas da projeção (metros) em coordenadas
geodéticas(radiano)
• Category
Esta classe implementa as características de cada classe geográfica definida no modelo de
dados conceitual do sistema. Os categorias podem ser dos seguintes modelos
Imagem, Temático, Numérico, Cadastral, Rede, Objetos e Não Espacial.
Alguns métodos desta classe são:
GeoClasses – Retorna a lista de classes temáticas, caso o modelo seja Temático
GetVisual – Retorna o visual da categoria
Model – Retorna o identificador do modelo da categoria
Name – Retorna o nome da categoria
SetVisual – Define o visual da categoria
Table – Retorna o nome da tabela, no caso de modelos de Objetos e Não
Espacial Visible – Retorna a visibilidade da categoria
Exemplos de Funcionalidades
• Infolayer
Esta classe é a generalização dos planos de informações no qual seus membros
armazenam as informações sobre uma determinada área de um tempo específico.
Alguns métodos desta classe são:
BoundingBox – Retorna o retângulo envolvente do plano de informação
CatCode – Retorna o identificador da categoria que o plano de informação esta
contido
Get – Retorna as representações do plano de informação
GetDB – Retorna o banco de dados que o plano de informação está contido
InsertRepres – Adiciona uma representação ao plano de informação
Label – Retorna o nome do plano de informação
Model - Retorna o modelo do plano de informação
Priority - Retorna a prioridade de desenho do plano de informação
Projection - Retorna a projeção do plano de informação
RemoveRepres – Remove uma representação do plano de informação
ResolutionX - Retorna a resolução X do plano de informação
ResolutionY - Retorna a resolução Y do plano de informação
Show – Desenha o plano de informação na área de desenho fornecida como
parâmetro Visible – Retorna ou define a visibilidade do plano de informação
• Vector
Esta classe implementa as operações sobre as representações vetoriais, no qual pode ser
manipulados em memória ou armazenado e recuperado do disco.
Alguns métodos desta classe são:
Adjust – Ajusta a representação vetorial criando a lista de nós
Anchors – Retorna as âncoras associadas a representação do vetor
FindAnchors – Retorna as lista de âncoras associadas ao vetor dado um ponto e
uma tolerância como parâmetros
FindLine – Retorna a linha mais próxima a um ponto e uma certa tolerância
FindNode – Retorna o nó mais próximo a um ponto e uma certa tolerância
FindPoint2d – Retorna o ponto 2D mais próximo a um ponto e uma certa tolerância
Exemplos de Funcionalidades
FindPoint3d – Retorna o ponto 3D mais próximo a um ponto e uma certa tolerância
FindPolygon – Retorna o polígono próximo a um ponto e uma certa tolerância
GenerateTopology – Gera a topologia referente ao ajuste realizado sobre a
representação vetorial
GetInfolayer – Retorna o plano de informação da representação
Insert – Adiciona uma representação ao vetor
Lines – Retorna as representações de linhas
Load – Carrega as informações vetoriais
Nodes – Retorna os nós gerados pelo ajuste
Points2d – Retorna as representações de pontos 2D
Points3d – Retorna as representações de pontos 3D
Polygons – Retorna as representações de polígonos
Save – Salva as informações vetoriais em disco
• Image
Esta classe implementa o controle da representação matricial, incluindo armazenamento,
acesso e manipulação para os diversos tipos de imagem.
Clear – Finaliza o controle na imagem
computeHistogram – Calcula o histograma da imagem
Coord2Index – Retorna os índices linha e coluna da imagem de um ponto passado
como parâmetro
dummyValue – Retorna o valor dummy da imagem
histogram – Retorna o histograma da imagem
Index2Coord – Retorna as coordenadas X e Y fornecendo os índices de linha e coluna
Init – Inicializa a imagem, apenas após esse métodos os atribuitos da imagem estão
acessíveis
level – Retorna o valor da imagem dado os índíces e o canal
LikeMe – Retorna a igualdade entre duas imagens Max –
Retorna o valor máximo da imagem
Min – Retorna o valor mínimo da imagem
NumCol – Retorna o número de colunas da imagem
NumLin – Retorna o número de linhas da imagem
Exemplos de Funcionalidades
ResolutionX – Retorna a resolução X da imagem
ResolutionY – Retorna a resolução Y da imagem
SetLimits – Atualiza os valores de máximo e mínimo da imagem
Visible – Retorna a visibilidade da imagem
• SNewFrame
Esta classe define a parte visual das janelas do SPRING e implementa os controles dos
componentes de interface.
AddActionMenu – Adiciona uma ação ao menu definido no parâmetro
addActionImagemMenu – Adiciona uma ação ao menu Imagem
addActionCadastralMenu – Adiciona uma ação ao menu Cadastral
addActionTematicoMenu – Adiciona uma ação ao menu Temático
addActionMNTMenu – Adiciona uma ação ao menu MNT
addActionRedeMenu – Adiciona uma ação ao menu Rede
Footer – Apresenta uma mensagem na barra de status
idTabWidget – Retorna o identificador da janela
• SpringFloatTabWidget
Esta classe possui duas funções, apresentar as janelas do SPRING em abas e realizar o
gerenciamento de apresentação das janelas.
getMainWindow – Retorna o ponteiro da janela do identificador passado como
parâmetro
getSpringWindow – Retorna o ponteiro das informações da janela do identificador
passado como parâmetro
getTabActive – Retorna o identificador da janela ativa
getTotalCount – Retorna a quantidade de janelas criadas
• SpringWindow
Esta classe armazena as informações de cada janela do SPRING.
pcont – Ponteiro do painel de controle
SGscale – Escala de desenho da janela
SGscalemode – Tipo de escala do último desenho (Auto, Pleno, Escala)
Exemplos de Funcionalidades
SGbox – Retângulo envolvente de desenho
SGgvis – Lista de planos de informação visíveis da janela
Variáveis
• SGcatL – CategoryList - Lista das categorias do banco de dados ativo
• SGdb – Database - Banco de dados ativo
• SGdbL – DatabaseList – Lista dos banco de dados do diretório selecionado
• SGobjcatL – CategoryList – Lista de categorias dos modelos de Objetos e Não Espacial
do banco de dados ativo
• SGProj – Project – Projeto ativo
• SGProjL – ProjectList – Lista dos projetos do banco de dado ativo
• SGinfo – InfoLayer - Plano de informação ativo
• SGinfoL – InfoLayerList – Lista dos planos de informação do projeto ativo
• newspringTabWidget – SpringFloatTabWidget – Ponteiro para a estrutura de interfaces
do SPRING
Exemplos de Funcionalidades
Exemplos de Funcionalidades
Transformada Rápida de Fourier
O início de qualquer inclusão de funcionalidades está associada a inclusão dos arquivos de
desenvolvimento nos arquivos de projetos. Nesta funcionalidade em específico, 6 arquivos serão
adicionados:
• fft.h
• fft.cpp
• fftw3.h
• fftdlg.h
• fftdlg.cpp
• uifftdlg.ui
Os arquivos fft.h, fftw3.h e fft.cpp farão parte do projeto libspring e para incluí-los no
projeto, é necessário modificar o arquivo projetos/libspring/libspring.inc com as seguintes
alterações:
#inclusao da funcionalidade da transformada de Fourier
HEADERS += ../../src/lib/include/fft.h \
../../src/lib/include/fftw3.h
SOURCES += ../../src/lib/fft.cpp
Enquanto os demais arquivos serão incluídos no projeto spring, pois os mesmos estão
relacionados a interface da funcionalidade. As modificações abaixo devem ser feitas no arquivo
projetos/spring/imagem.inc, pois essa funcionalidade será executada em imagens.
#fftdlg
HEADERS += ../../src/springqt/include/fftdlg.h
INTERFACES += ../../src/springqt/ui/uifftdlg.ui
SOURCES += ../../src/springqt/fftdlg.cpp
Observação, a macro “HEADERS +=” adiciona arquivos de definição ao projeto, a macro
“SOURCES +=” adiciona arquivos de implementação ao projeto e a macro “INTERFACES +=” inclui
arquivos de interface ao projeto.
Além dos arquivos é necessário adicionar a biblioteca que contém a implementação da
transformada de Fourier, FFTW (http://www.fftw.org/), para adicioná-la ao SPRING, faça os
seguintes passos:
Exemplos de Funcionalidades
• Windows
◦ Altere o arquivo projetos/libspring/libspring.pro adicionando as seguintes
linhas ao final do arquivo:
contains(SPRINGOPERATIONALS,SPRING_WINDOWS){
LIBS += $${DESTDIR}/libfftw.lib }
• Linux
◦ Instale a biblioteca fftw através do seguinte comando (obrigatório ser
usuário root):
▪ Ubuntu
• apt-get install fftw3
▪ OpenSuse
• yast2 –-install fftw3
◦ Altere o arquivo projetos/spring/spring.pro adicionando as seguintes linhas
ao final do arquivo:
contains(SPRINGOPERATIONALS,SPRING_LINUX){
LIBS += -lfftw3
}
Após a inclusão dos arquivos nos arquivos de projetos e da biblioteca FFTW é estritamente
necessário regerar os projetos.
• Abra um Prompt de Comando(Windows) ou Terminal(Linux)
• Defina na variável QTDIR o diretório de instalação do framework Qt
◦ Windows
▪ set QTDIR=C:\Qt\4.6.2
◦ Linux
▪ set QTDIR=/usr/local/TrollTech/Qt-4.6.2
• Defina o tipo de arquivo de projetos
◦ Windows Visual Studio
▪ set QMAKESPEC=win32-msvc2008
◦ Linux
▪ set QMAKESPEC=linux-g++
Esses passos estão exemplificados nos arquivos <vscmd-32-qt.bat>(Windows)
Exemplos de Funcionalidades
• Gerando os arquivos de projetos
◦ Windows (Visual Studio)
▪ Execute o script gerarvcproj.bat
◦ Linux
▪ Execute o script ./gerarmakefile.sh
◦ Escolha o ambiente de compilação
Após esses passos o SPRING está pronto para ser compilado novamente, para isso faça
• Windows Visual Studio
◦ Abra o arquivo projetos/projetos.sln
• Linux GCC/G++
◦ Execute o comando make -f MakefileSpring
A partir desse ponto o SPRING está preparado para executar a funcionalidade da
Transformada Rápida de Fourier.
Analisaremos a implementação da funcionalidade da transformada rápida de Fourier
apresentando os métodos e as particularidades no desenvolvimento de operações para o SPRING.
Nos métodos presentes no arquivo fftdlg.cpp encontramos diversos usos de classes do SPRING,
que manipulam banco de dados, projetos, planos de informação e a representação imagem.
O código abaixo é responsável por executar a transformada rápida de Fourier, esse método
é executado quando o botão executar é pressionado.
void QTfft::slotTransformFFT()
{
//Representação Imagem
Image* srcImage;
//Retorna verdadeiro se o plano possui uma representação imagem e caso possua atribue a variável srcImage
if (SGinfo->Get(srcImage))
{
//Obtém os valores presentes nos campos de texto da interface relacionados ao nome dos planos
de informação de saída
QString realName = ui.reallayerLed->text();
QString imagName = ui.imaglayerLed->text();
int rows = FastFourierTransformation::max_pow2(srcImage->NumLin());
int cols = FastFourierTransformation::max_pow2(srcImage->NumCol());
//Cria um plano de informação com uma representação imagem no banco de dados SGdb, no projeto
SGProj, na categoria Sginfo->GetCategory() e nome realName [email protected] 25
Exemplos de Funcionalidades
//A representação imagem possuirá rows linhas e cols colunas, será de 32 bits e tipo REAL4
InfoLayer* dstReal = createInfoLayer(SGdb,SGProj,SGinfo->GetCategory(),realName,rows,cols,32,"REAL4");
if (!dstReal)
{
//Retorna caso o plano de informação não tenha sido criado
SMessageBox::Show(MBINFORMATION,NULL,QObject::tr("Fast Fourier"),QObject::tr("Plano de Informação
%1 não foi criado!").arg(realName));
return;
}
realName += "-Freq";
InfoLayer* dstRealFeq = createInfoLayer(SGdb,SGProj,SGinfo->GetCategory(),realName,rows,cols,32,"REAL4");
if (!dstRealFeq)
{
SMessageBox::Show(MBINFORMATION,NULL,QObject::tr("Fast Fourier"),QObject::tr("Plano de Informação %1
não foi criado!").arg(realName));
return;
}
InfoLayer* dstImag = createInfoLayer(SGdb,SGProj,SGinfo->GetCategory(),imagName,rows,cols,32,"REAL4");
if (!dstImag)
{
SMessageBox::Show(MBINFORMATION,NULL,QObject::tr("Fast Fourier"),QObject::tr("Plano de Informação %1
não foi criado!").arg(realName));
return;
}
imagName += "-Freq";
InfoLayer* dstImagFeq = createInfoLayer( Sgdb, SGProj ,Sginfo->GetCategory(), imagName, rows, cols, 32, "REAL4");
if (!dstImagFeq)
{
SMessageBox::Show(MBINFORMATION,NULL,QObject::tr("Fast Fourier"),QObject::tr("Plano de Informação
%1 não foi criado!").arg(realName));
return;
}
//Representação Imagem
Exemplos de Funcionalidades
Image* dstReali;
Image* dstImagi;
Image* dstRealf;
Image* dstImagf;
//Obtém as representações imagem de todos os planos de informação criados anteriormente
if (dstReal->Get(dstReali) && dstImag->Get(dstImagi) && dstRealFeq->Get(dstRealf) && dstImagFeq-
>Get(dstImagf))
{
//Executa a transformada rápida de Fourier, o dado de entrada é a representação imagem srcImage do
plano ativo
//E as informações de saída são as representações imagem dstReali,dstImagi,dstRealf,dstImagf
FastFourierTransformation fftransf;
fftransf.transform(srcImage,dstReali,dstImagi,dstRealf,dstImagf);
}
}
}
O código abaixo é responsável por criar um plano de informação com uma representação
imagem.
InfoLayer* QTfft::createInfoLayer( DataBase* bancoDados, Project* projeto, Category* ilCategory, QString layerName, int
nlin, int ncol, int numbits,string imgtype )
{
//Verifica se o banco de dados foi definido
if (!bancoDados)
{
SMessageBox::Show(MBINFORMATION,NULL,QObject::tr("Fast Fourier"),QObject::tr("Defina o banco de dados de saída!"));
return NULL;
}
//Verifica se o projeto foi definido
if (!projeto)
{
SMessageBox::Show(MBINFORMATION,NULL,QObject::tr("Fast Fourier"),QObject::tr("Defina o projeto de
saída!"));
return NULL;
}
Exemplos de Funcionalidades
//Verifica se a categoria foi definida
if (!ilCategory)
{
SMessageBox::Show(MBINFORMATION,NULL,QObject::tr("Fast Fourier"),QObject::tr("Defina a categoria de saída!"));
return NULL;
}
//Verifica se o nome foi definido
if (layerName.isNull() || layerName.isEmpty())
{
SMessageBox::Show(MBINFORMATION,NULL,QObject::tr("Fast Fourier"),QObject::tr("Defina o nome do plano de
informação!"));
return NULL;
}
//Verifica se já existe um plano de informação com este nome
InfoLayer* il = bancoDados->InfoLayerExists (layerName.toLatin1().data(), ilCategory);
if (il)
{
//Caso exista, é feita uma pergunta se deseja remover o existente e criar um novo
if (SMessageBox::Show (MBQUESTION, NULL, QObject::tr("Fast Fourier"), QObject::tr("Plano de Informação %1 já
existe. Deseja remover?").arg(layerName) ) == QMessageBox::No)
{
//Retorna que não quer sobreescrever
return NULL;
}
else
{
//Apaga o plano de informação
if (!bancoDados->DeleteInfoLayer(projeto, il))
{
SMessageBox::Show (MBINFORMATION,NULL, QObject::tr("Fast Fourier"), QObject::tr("Não
foi possível remover o Plano de Informação!") );
return NULL;
}
}
}
Exemplos de Funcionalidades
int cmodel = ilCategory->Model();
double scale = 25000.;
Box imgBox = SGinfo->BoundingBox();
Box prjBox = SGinfo->LLBox();
double rx = imgBox.Width() / (double)ncol;
double ry = imgBox.Height() / (double)nlin;
Stime tim;
//Cria um novo plano de informação
bancoDados->NewInfoLayer (il, projeto, ilCategory, layerName.toLatin1().data(), imgBox, prjBox, cmodel, scale, rx,
ry, tim, imgtype);
Image* digital;
//Cria uma nova representação imagem para o novo plano de informação
if(!bancoDados->NewImage(digital, il, IMAGE, numbits, imgtype)) {
SMessageBox::Show (MBINFORMATION,NULL, QObject::tr("Fast Fourier"), QObject::tr("Erro ao criar a
imagem!"));
return NULL;
}
//Atualiza a representação no banco de dados
bancoDados->UpdateRepresentation( digital );
//Abre e fecha a representação imagem confirmando sua criação
digital->Init();
digital->Clear();
//Retorna o novo plano de informação
return il;
}
Examinaremos abaixo o código presente no método transform do arquivo fft.cpp Este
método é a transformação direta que recebe uma imagem monocromática e gera quatro imagens:
a parte real e imaginária da transformação e a parte real e imaginária da transformação
normalizada por uma função logarítmica.
bool FastFourierTransformation::transform(Image* src, Image* dstReal, Image* dstImag, Image* dstRealFeq, Image*
dstImagFeq)
Exemplos de Funcionalidades
{
if (!src && !dstReal && !dstImag)
return false;
//inicializa a representação imagem
src->Init();
dstReal->Init();
dstImag->Init();
dstRealFeq->Init();
dstImagFeq->Init();
or = src->NumLin();
oc = src->NumCol();
rows = max_pow2(or);
cols = max_pow2(oc);
totsize = rows * cols;
double *data[2];
string itemWidth = "FourierWidth";
string valueWidth = QString("%1").arg(oc).toStdString();
string itemHeight = "FourierHeight";
string valueHeight = QString("%1").arg(or).toStdString();
DescriptorItem itemW(itemWidth,valueWidth);
DescriptorItem itemH(itemHeight,valueHeight);
dstImag->descriptor().addItem(itemW);
dstImag->descriptor().addItem(itemH);
dstImag->descriptor().save();
dstReal->descriptor().addItem(itemW);
dstReal->descriptor().addItem(itemH);
dstReal->descriptor().save();
// Alocando memoria para a estrutura de dados
Exemplos de Funcionalidades
data[0] = (double *) malloc((rows*cols)*sizeof(double));
data[1] = (double *) malloc((rows*cols)*sizeof(double));
if (data[0] == NULL || data[1] == NULL)
return false;
// Inicializando a parte real e complexa com
zero register double *dptr1, *dptr0 ;
dptr0=data[0] ;
dptr1=data[1] ;
for (int i=0; i<totsize; i++) {
*dptr0++ = *dptr1++ = 0.0 ;
}
//Lendo os valores da imagem
for (int i=0; i<or; i++) {
for (int j=0; j<oc; j++)
*(data[0]+(i*cols)+j) = (double) (*src)(i,j);
}
//Starting FFT...
fft(-1,data,totsize,cols,rows);
//FFT completed...
//Rotacionando os dados para melhor visualização
double temp;
for (int i=0; i<rows; i++) {
for (int j=0; j<cols/2; j++) {
temp = *(data[0]+i*cols+j);
*(data[0]+i*cols+j) = *(data[0]+i*cols+j+cols/2);
*(data[0]+i*cols+j+cols/2) = temp;
temp = *(data[1]+i*cols+j);
*(data[1]+i*cols+j) = *(data[1]+i*cols+j+cols/2);
*(data[1]+i*cols+j+cols/2) = temp;
}
}
for (int i=0; i<rows/2; i++) {
Exemplos de Funcionalidades
for (int j=0; j<cols; j++) {
temp = *(data[0]+i*cols+j);
*(data[0]+i*cols+j) = *(data[0]+(i+rows/2)*cols+j);
*(data[0]+(i+rows/2)*cols+j) = temp;
temp = *(data[1]+i*cols+j);
*(data[1]+i*cols+j) = *(data[1]+(i+rows/2)*cols+j);
*(data[1]+(i+rows/2)*cols+j) = temp;
}
}
double minimoTotal = 999999999999999.;
double maximoTotal = -999999999999999.;
//Obtendo os valores minimo e máximo
for (int i=0; i<or; i++) {
for (int j=0; j<oc; j++)
{
double valor = *(data[0]+(i*cols)+j);
if (valor > maximoTotal)
maximoTotal = valor;
if (valor < minimoTotal)
minimoTotal = valor;
valor = *(data[1]+(i*cols)+j);
if (valor > maximoTotal)
maximoTotal = valor;
if (valor < minimoTotal)
minimoTotal = valor;
}
}
double minimoR = 999999999999999.;
double maximoR = -999999999999999.;
double minimoI = 999999999999999.;
double maximoI = -999999999999999.;
//Atribuindo a estrutura real e complexa a imagem
Exemplos de Funcionalidades
{
register double *data0, *data1 ;
for (int i=0; i<rows; i++) {
data0 = data[0] + i * cols ;
data1 = data[1] + i * cols ;
for (int j=0; j<cols; j++) {
double valor = (int) (*data0++);
(*dstReal)(i,j) = valor;
if (valor > maximoR)
maximoR = valor;
if (valor < minimoR)
minimoR = valor;
valor = (int) (*data1++);
(*dstImag)(i,j) = valor;
if (valor > maximoI)
maximoI = valor;
if (valor < minimoI)
minimoI = valor;
}
}
}
dstReal->SetLimits(minimoR,maximoR);
dstImag->SetLimits(minimoI,maximoI);
minimoR = 999999999999999.;
maximoR = -999999999999999.;
minimoI = 999999999999999.;
maximoI = -999999999999999.;
//Atribuindo a estrutura real e complexa normalizada pelo Range e pela função logaritmica
double Range = 255;
double scale = (double)Range / log(1.0 + maximoTotal > -maximoTotal ? maximoTotal : -maximoTotal);
{ [email protected] 33
Exemplos de Funcionalidades
register double *data0, *data1 ;
for (int i=0; i<rows; i++) {
data0 = data[0] + i * cols ;
data1 = data[1] + i * cols ;
for (int j=0; j<cols; j++) {
double valor = (int) (log(1.0+fabs(*data0++)) * scale);
(*dstRealFeq)(i,j) = valor;
if (valor > maximoR)
maximoR = valor;
if (valor < minimoR)
minimoR = valor;
valor = (int) (log(1.0+fabs(*data1++)) * scale);
(*dstImagFeq)(i,j) = valor;
if (valor > maximoI)
maximoI = valor;
if (valor < minimoI)
minimoI = valor;
}
}
}
//Atualizando os valores de minimo e máximo das imagens de saída
dstRealFeq->SetLimits(minimoR,maximoR); dstImagFeq-
>SetLimits(minimoI,maximoI);
//Finalizando o uso das representações imagem
src->Clear();
dstReal->Clear();
dstImag->Clear();
dstRealFeq->Init();
dstImagFeq->Init();
//Liberando a estrutura
free(data[1]);
Exemplos de Funcionalidades
free(data[0]);
return true;
}
Após a interface e a funcionalidade adicionadas ao projeto do SPRING, é necessário
habilitar o acesso dessa para os usuários. Para isso o SPRING possui algumas operações que
auxiliam a inclusão de novas funcionalidades. Abaixo apresentamos a inclusão da operação da
Transformada Rápida de Fourier no menu Imagem do SPRING.
Primeiro deve-ser criar o método de criação da janela da nova funcionalidade. Como segue
o exemplo a baixo, implementado no arquivo fftdlg.cpp.
void fftdlg()
{
//Obtém as informações da janela ativa
QWidget* frame = newspringTabWidget->getMainWindow(SGcur);
if (!frame)
return;
//Caso a janela não tenha sido criada ou não foi encontrada na lista de Widget da
aplicação if((!fftFcFrame) || (!fftFcFrame->GetOpaque())) {
//caso a janela exista, remove a ultima referência
if(fftFcFrame)
{
windowLst.removeAll(fftFcFrame);
fftFcFrame = NULL;
}
//cria a janela
fftFcFrame = new Qtfft(frame);
windowLst.append(fftFcFrame);
}
//inicializa a janela, escondida e modal
if (fftFcFrame->Init(frame,frame->winId(),FALSE,TRUE))
{
}
Exemplos de Funcionalidades
}
Depois, é necessário adicionar a chamada da funcionalidade da Transformação Rápida de
Fourier, neste caso utilizaremos um método para realizar essa inclusão, implementado no arquivo
fftdlg.cpp.
void addFFTAction(SNewFrame* janela)
{
//Cria e adiciona uma ação ao menu imagem
janela->addActionImagemMenu(QObject::tr("Transformada Rápida de Fourier"),NULL,(ACTIONCALLFUNC)fftdlg);
}
Para finalizar e por fim utilizar sua nova funcionalidade, adicione a chamada da função
anterior na inicialização das janelas do SPRING no método newspring() do arquivo
newspring_ui.cpp. Neste caso a alteração deve ser feita conforme o exemplo abaixo.
void newspring (SNewFrame* frame)
{
SpringWindow* sp = newspringTabWidget->getSpringWindow(frame);
…
// Initialize the SButton object "springBZoom" sp-
>springBZoom.Init(frame,frame->newspringDlg.zoomBtn->winId());
// Initialize the SButton object "springBLink" sp-
>springBLink.Init(frame,frame->newspringDlg.linkBtn->winId());
void addFFTAction(SNewFrame*);
addFFTAction(frame);
}