Este tutorial tem como objetivo apresentar a classe TDK utilizada para criação
de projeções e execução de operações sobre a mesma, através de exemplos
práticos e definições.
|
|
Aguarde. Em construção !!! Abaixo uma idéia do que estamos preparando ...
|
| |
|
Introdução
|
|
O módulo de processamento provê funcionalidades que auxiliam as tarefas de
calcular, converter e selecionar áreas georeferenciadas.
Para melhor entendimento desta etapa do tutorial é necessário o conhecimento
das seguintes definições:
A superfície terrestre sofre freqüentes alterações devido à natureza (movimentos
tectônicos, condições climáticas, erosão, etc.) e à ação do homem, portanto,
não serve para definir forma sistemática da Terra.
Segundo o conceito introduzido pelo matemático alemão Carl Friedrich Gauss,
a forma do planeta, é o GEÓIDE. Entretanto, a fim de simplificar o cálculo
de coordenadas da superfície terrestre usamos um modelo mais simples para
representar o nosso planeta. No caso, consideramos que a terra é
uma ELIPSE que ao girar em torno do seu eixo menor forma um volume, o
ELIPSÓIDE DE REVOLUÇÃO, achatado no pólos. Assim, o elipsóide é a superfície de
referência utilizada nos cálculos que fornecem subsídios para a elaboração de
uma representação cartográfica.
Muitos foram os intentos realizados para calcular as dimensões do elipsóide de
revolução que mais se aproxima da forma real da Terra, e muitos foram os
resultados obtidos. Em geral, cada país ou grupo de países adotou um elipsóide
como referência para os trabalhos geodésicos e topográficos, que mais se
aproximasse do geóide na região considerada. A forma e tamanho de um elipsóide,
bem como sua posição relativa ao geóide define um sistema geodésico (também
designado por datum geodésico). No caso brasileiro adota-se o
Sistema Geodésico Sul Americano - SAD 69. Ou seja, um datum é um modelo
matemático da forma da superfície terrestre caracterizando-se por uma
superfície de referência posicionada em relação a Terra.
Uma projeção representa a referência geográfica da componente
espacial dos dados geográficos, permitindo projetar a superfície terrestre em
uma superfície plana.
Uma área retangular de uma projeção é chamada de box e é
determinada por dois valores da coordenada X (xmin e xmax) e dois valores da
coordenada Y(ymin, ymax).
A Terralib fornece a classe TeProjection para representação de uma
projeção e a estrutura TeProjectionParams para a representação dos
parâmetros de uma projeção (contendo um conjunto de especializações de
projeções mais comuns como a LatLong e a UTM, Mercator ou Policônica).
Dentre todas as funcionalidades que o módulo de processamento nos fornece, vamos
estudar as principais:
Cálculo de Distância LatLong entre Dois Pontos
Convertendo Coordenadas de um Box
Convertendo Coordenadas de duas Projeções
Criar projeção LatLong
Criar projeção UTM
Criar uma nova projeção
|
|
Instruções Iniciais
|
|
Em construção !
|
|
1) Cálculo de Distância LatLong entre Dois Pontos
|
| |
A primeira funcionalidade que iremos ver é a do cálculo da distância LatLong
(em metros) entre dois pontos determinados. Este calculo é feito através do
método calcLatLongDistanceInMeters que retorna o resultado sob o tipo double.
1.1) Edite o código fonte do arquivo TDK_processingServ.cpp criado para
deixá-lo da seguinte forma:
|
#include "stdafx.h"
#include "TdkException.h"
#include "TdkProcessingService.h"
int _tmain(int argc, char* argv[])
{
//Cria parâmetros para uma projeção
TeProjectionParams params;
params.name = "UTM";
params.datum = TeDatumFactory::make("CorregoAlegre");
params.lon0 = 2.23;
params.lat0 = 0.11;
//Especifica coordenadas em graus
double x1 = 110.0; double y1 = 30.0;
double x2 = 120.0; double y2 = 30.0;
try {
//Cria uma projeção parametrizada
TeProjection* proj=TdkProcessingService::createProjection(params);
//Calcula a distância, retornando o valor para “distance”
double distance =TdkProcessingService::calcLatLongDistanceInMeters(x1, y1,
x2, y2, "SAD69", proj);
//Exibe o resultado
std::cout << "Distancia : " << distance << "\n\nPressione qualquer tecla para sair.";
getchar();
} catch (TdkException* ex) {
//Trata erro.
}
return 0;
}
|
|
|
|
|
1.2) Ao executar a aplicação, aparecerá na tela o valor da distância calculada.
|
|
|
|
|
2) Convertendo Coordenadas de um Box
|
Veremos agora o método convertBox, utilizado para converter as coordenadas de
um box usando duas projeções especificadas.
2.1) Crie um novo arquivo com o nome TDK_convertBox.cpp e edite seu código para
deixá-lo da seguinte forma:
|
#include "stdafx.h"
#include "TdkException.h"
#include "TdkProcessingService.h"
void main(int argc, char* argv[])
{
//Cria projeção
TeProjection* proj1 = TdkProcessingService::createSimpleUTMProjection();
TeProjection* proj2 = TdkProcessingService::createSimpleLatLongProjection();
//Especifica coordenadas em graus
double x1 = 110.0; double y1 = 30.0;
double x2 = 120.0; double y2 = 30.0;
//Exibe o valor das coordenadas do box antes da Conversao
std::cout << "Valor das coordenadas do box antes da Conversao:\n\nx1: " << x1 << " y1: " << y1;
std::cout << "\nx2: " << x2 << " y2: " << y2 << "\n\n";
try {
//Converte o Box de “proj1” para “proj2”
TdkProcessingService::convertBox(x1,y1,x2,y2,*proj1,*proj2);
//Exibe o valor das coordenadas do box apos a Conversao
std::cout << "Valor das coordenadas do box apos a Conversao:\n\nx1: " << x1 << " y1: " << y1;
std::cout << "\nx2: " << x2 << " y2: " << y2 << "\n\n";
std::cout << "Pressione qualquer tecla para sair.";
getchar();
} catch (TdkException* ex) {
//Trata erro.
}
}
|
|
|
|
2.2) Ao executar a aplicação, aparecerá na tela os valores das coordenadas do
box antes e depois da Conversão.
|
|
|
|
|
3) Convertendo Coordenadas de duas Projeções
|
A próxima funcionalidade é a do método convertCoord2D, que serve para converter
coordenadas dadas (X e Y) usando duas projeções especificadas.
3.1) Crie um novo arquivo com o nome TDK_convertCoord2D.cpp e edite seu código
para deixá-lo da seguinte forma:
|
#include "stdafx.h"
#include "TdkException.h"
#include "TdkProcessingService.h"
void main(int argc, char* argv[])
{
//Cria projeções
TeProjection* proj1 = TdkProcessingService::createSimpleUTMProjection();
TeProjection* proj2 = TdkProcessingService::createSimpleLatLongProjection();
//Especifica coordenada em graus
double x = 110.0; double y = 30.0;
//Exibe o valor das coordenadas antes da Conversao
std::cout << "Valor das coordenadas 2D antes da Conversao:\n\nx: " << x << " y: "<< y << "\n\n";
try {
//Converte coordenadas 2D de “proj1” para “proj2”
TdkProcessingService::convertCoord2D(x,y,*proj1,*proj2);
//Exibe o valor das coordenadas apos a Conversao
std::cout << "Valor das coordenadas 2D apos a Conversao:\n\nx: " << x << " y: "<< y << "\n\n";
std::cout << "Pressione qualquer tecla para sair.";
getchar();
} catch (TdkException* ex) {
//Trata erro.
}
}
|
|
|
|
3.2) Ao executar a aplicação, aparecerá na tela os valores das coordenadas antes
e depois da Conversão.
|
|
|
|
|
4) Criando uma Projeção LatLong
|
Veremos agora o método createSimpleLatLongProjection que cria uma projeção
LatLong com valores padrão, retornando um ponteiro para a projeção criada sob o
tipo TeProjection.
4.1) Crie um novo arquivo com o nome TDK_createLatLongProj.cpp e edite seu
código para deixá-lo da seguinte forma:
|
#include "stdafx.h"
#include "TdkException.h"
#include "TdkProcessingService.h"
void main(int argc, char* argv[])
{
try {
//Cria projeção com parâmetro padrão
TeProjection* proj = TdkProcessingService::createSimpleLatLongProjection();
//Exibe aviso de criação com sucesso.
std::cout << "Projecao " << proj->params().name.data() << " criada com sucesso.\n\n";
std::cout << "Pressione qualquer tecla para sair.";
getchar();
} catch (TdkException* ex) {
//Trata erro
}
}
|
|
|
|
4.2) Ao executar a aplicação, aparecerá na tela um aviso de criação da projeção
com sucesso.
|
|
|
|
|
5) Criando uma Projeção UTM
|
Com o método createSimpleUTMProjection criamos uma projeção UTM com valores
padrão, ou seja, este método não é parametrizado e retorna um ponteiro para a
projeção criada sob o tipo TeProjection.
5.1) Crie um novo arquivo com o nome TDK_createUTMProj.cpp e edite seu código
para deixá-lo da seguinte forma:
|
#include "stdafx.h"
#include "TdkException.h"
#include "TdkProcessingService.h"
void main(int argc, char* argv[])
{
try {
//Cria projeção com parâmetro padrão
TeProjection* proj = TdkProcessingService::createSimpleUTMProjection();
//Exibe aviso de criação com sucesso.
std::cout << "Projecao " << proj->params().name.data() << " criada com sucesso.\n\n";
std::cout << "Pressione qualquer tecla para sair.";
getchar();
} catch (TdkException* ex) {
//Trata erro
}
}
|
|
|
|
5.2) Ao executar a aplicação, aparecerá na tela um aviso de criação da projeção
com sucesso.
|
|
|
|
|
6) Criando uma Nova Projeção
|
A próxima funcionalidade é a do método createProjection, que cria uma nova
projeção com parâmetros definidos pelo usuário, retornando a projeção criada
sob o tipo TeProjection.
6.1) Crie um novo arquivo com o nome TDK_createProjection.cpp e edite seu
código para deixá-lo da seguinte forma:
|
#include "stdafx.h"
#include "TdkException.h"
#include "TdkProcessingService.h"
void main(int argc, char* argv[])
{
//Cria parâmetros para projeção
TeProjectionParams params;
params.name = "UTM";
params.datum = TeDatumFactory::make("CorregoAlegre");
params.lon0 = 2.23;
params.lat0 = 0.11;
try {
//Cria projeção com parâmetro definido
TeProjection * proj = TdkProcessingService::createProjection(params);
//Exibe os parametros da projeção criada
std::cout << "Parametros da Projecao criada:\n\n ";
std::cout << "Nome: " << proj->name().data() << "\n ";
std::cout << "Datum: " << proj->datum().name().data() << "\n ";
std::cout << "lat: " << proj->lat0() << "\n ";
std::cout << "lon: " << proj->lon0() << "\n ";
std::cout << "\n\nPressione qualquer tecla para sair.";
getchar();
} catch (TdkException* ex) {
//Trata erro
}
}
|
|
|
|
6.2) Ao executar a aplicação, aparecerá na tela os parâmetros da projeção
criada.
|
|
|
|
|
|
Topo ^
|