MINISTÉRIO DA DEFESA

DEPARTAMENTO DE CIÊNCIA E TECNOLOGIA

INSTITUTO MILITAR DE ENGENHARIA
(Real Academia de Artilharia, Fortificação e Desenho, 1792)

SEÇÃO DE ENGENHARIA CARTOGRÁFICA (SE/6)

GEODÉSIA GEOMÉTRICA

Transporte de Coordenadas Geodésicas

PROF HAROLDO

TURMA: 3º ANO

EDSON TADEU DA SILVA PINTO - 1º Ten - 21109

Rio de Janeiro
2022
 1 FÓRMULAS DE PUISSANT

1 Fórmulas de Puissant
1.1 1ª questão
1.1.1 Problema Direto

Dadas as coordenadas de P1 (ϕ1 , λ1 ), o azimute (α12 ) e a distância (S12 ), aplicando-as nas fórmulas
de Puissant para a resolução do Problema Direto, através do código-fonte em Python, conforme anexo,
obtém-se as seguintes coordenadas pedidas:
ϕ2 = 22◦ 9′ 59, 58915” S
λ2 = 50◦ 54′ 15, 414872” O
α21 = 275◦ 19′ 19, 583216”

1.1.2 Problema Inverso

Dadas as coordenadas de P1 (ϕ1 , λ1 ), e as de P2 (ϕ2 , λ2 ) obtidas do exercı́cio anterior, aplicando-as

nas fórmulas de Puissant para a resolução do Problema Inverso, através do código-fonte em Python,
conforme anexo, obtém-se os seguintes:
α12 = 95◦ 24′ 50, 357512”
◦ ′
α21 = 275 19 19, 583216”
S12 = 49.177, 35 m

1.2 2ª questão
Ao baixar o aplicativo com a formulação de T. Vicenty indicado na questão, obtém-se o seguinte:

Figura 1: Formulação de T. Vicenty

(a) Problema Direto (b) Problema Inverso

1.2.1 Problema Direto

ϕ2 = 22◦ 9′ 59, 58679” S

◦ ′
λ2 = 50 54 15, 41193” O
α21 = 275◦ 19′ 19, 5821”

2
1.3 3ª questão 1 FÓRMULAS DE PUISSANT

1.2.2 Problema Inverso

α12 = 95◦ 30′ 14, 7399”

◦
α21 = 275 19′ 19, 9131”
S12 = 49.999, 9228 m

1.3 3ª questão
1.3.1 Problema Direto

A diferença entre as latitudes de P2 foi de 0, 00236”, entre as longitudes de P2 foi de 0, 002942”, entre
os contra-azimutes foi de 0, 001116”, ou seja, as coordenadas de P2 e os contra-azimutes obtidos tiveram
uma precisão com erro menor que 1 centésimo de segundo.

1.3.2 Problema Inverso

A diferença entre os azimutes obtidos foi de 5′ 24, 38239”, ou seja, foram 324,38239 segundos de
diferença entre os métodos distintos. Entre os contra-azimutes obtidos foi de 0, 329884”, ou seja, um erro
menor que 1 segundo. Entre as distâncias obtidas, foi de 822,5728 m, ou seja, quase 1 km de diferença.
Observa-se que, no problema inverso, estes métodos têm diferenças maiores comparado com o problema
direto.

3
 Transporte de Coordenadas Geodésicas

May 18, 2022

[2]: from math import sin, cos, sqrt, pi, tan, fabs, atan

PROBLEMA DIRETO

[3]: phi_graus = int(input('Insira os graus da latitude: '))

phi_minutos = int(input('Insira os minutos da latitude: '))
phi_segundos = float(input('Insira os segundos da latitude: '))
phi = phi_graus+(phi_minutos/60)+(phi_segundos/3600)
phi_rad = phi*(pi/180)
while True:
n_s = str(input('Informe se é norte (positivo) ou sul (negativo) [N/S]: ')).
,→upper().strip()[0]

if n_s == 'S' or n_s == 'N':

if n_s == 'S':
phi_rad = -phi_rad
phi = -phi
break

print(f'\nA latitude dada é {phi_graus}° {phi_minutos}\' {phi_segundos}\" {n_s} /

,→ {phi:.5f}°')

Insira os graus da latitude: 22

Insira os minutos da latitude: 7
Insira os segundos da latitude: 26.24
Informe se é norte (positivo) ou sul (negativo) [N/S]: s

A latitude dada é 22° 7' 26.24" S / -22.12396°

[4]: lambda_graus = int(input('Insira os graus da longitude: '))

lambda_minutos = int(input('Insira os minutos da longitude: '))
lambda_segundos = float(input('Insira os segundos da longitude: '))
lambida = lambda_graus+(lambda_minutos/60)+(lambda_segundos/3600)
lambda_rad = lambida*(pi/180)
while True:
l_o = str(input('Informe se é leste (positivo) ou oeste (negativo) [L/O]:␣
,→')).upper().strip()[0]

if l_o == 'L' or l_o == 'O':

if l_o == 'O':

1
 lambda_rad = -lambda_rad
lambida = -lambida
break

print(f'\nA longitude dada é {lambda_graus}° {lambda_minutos}\'␣

,→{lambda_segundos}\" {l_o} / {lambida:.5f}°')

Insira os graus da longitude: 51

Insira os minutos da longitude: 23
Insira os segundos da longitude: 12.55
Informe se é leste (positivo) ou oeste (negativo) [L/O]: o

A longitude dada é 51° 23' 12.55" O / -51.38682°

[5]: azimute_graus = int(input('Insira os graus do azimute: '))

azimute_minutos = int(input('Insira os minutos do azimute: '))
azimute_segundos = float(input('Insira os segundos do azimute: '))
azimutei = azimute_graus+(azimute_minutos/60)+(azimute_segundos/3600)
azimute_rad = azimutei*(pi/180)
print(f'\nO azimute dado é {azimute_graus}° {azimute_minutos}\'␣
,→{azimute_segundos}\" / {azimutei:.5f}°')

Insira os graus do azimute: 95

Insira os minutos do azimute: 30
Insira os segundos do azimute: 14.41

O azimute dado é 95° 30' 14.41" / 95.50400°

[6]: s = float(input('Insira a distância (m): '))

Insira a distância (m): 50000

[7]: a = float(input('Insira o semi-eixo maior [Digite "9" para GRS80]: '))

if a == 9:

a = 6378137
inv_f = 298.2572221

else:
inv_f = float(input('Insira o inverso do achatamento: '))

f = 1/inv_f
e = sqrt(2*f-f**2)

print(f'O semi-eixo maior é {a}m, o inverso do fator de achatamento é {inv_f} e␣

,→a primeira excentricidade é {e}.')

Insira o semi-eixo maior [Digite "9" para GRS80]: 9

2
 O semi-eixo maior é 6378137m, o inverso do fator de achatamento é 298.2572221 e
a primeira excentricidade é 0.08181919104295272.

[8]: M = (a*(1-e**2))/((1-(e**2)*(sin(phi_rad))**2)**(3/2))
N = a/((1-(e**2)*(sin(phi_rad))**2)**(1/2))

print(f'A seção normal meridiana M é {M}m e a seção normal primeiro vertical é␣

,→{N}m.')

A seção normal meridiana M é 6344473.3564759m e a seção normal primeiro vertical

é 6381167.198218857m.

[9]: erro = 10**(-9)

dphi_i = 0
dphi_j = (((s*cos(azimute_rad))/M)-((s**2*tan(phi_rad)*sin(azimute_rad)**2)/
,→(2*M*N))-((s**3*cos(azimute_rad)*sin(azimute_rad)**2*(1+3*tan(phi_rad)**2))/

,→(6*M*N)**2))*(1-((3*e**2*sin(phi_rad)*cos(phi_rad)*dphi_i)/

,→(2*(1-e**2*sin(phi_rad)**2))))

diferença = abs(dphi_j-dphi_i)

while diferença >= erro:

dphi_i = dphi_j
dphi_j = (((s*cos(azimute_rad))/M)-((s**2*tan(phi_rad)*sin(azimute_rad)**2)/
,→(2*M*N))-((s**3*cos(azimute_rad)*sin(azimute_rad)**2*(1+3*tan(phi_rad)**2))/

,→(6*M*N)**2))*(1-((3*e**2*sin(phi_rad)*cos(phi_rad)*dphi_i)/

,→(2*(1-e**2*sin(phi_rad)**2))))

diferença = abs(dphi_j-dphi_i)

if diferença < erro:

dphi = dphi_i
break

phi_rad_2 = phi_rad + dphi

phi_grau_2 = phi_rad_2*(180/pi)
phi_grau_2_n = fabs(phi_grau_2)
phi_minuto_2 = 60*(phi_grau_2_n-(int(phi_grau_2_n)))
phi_segundo_2 = 60*(phi_minuto_2-(int(phi_minuto_2)))
print(f'\nA latitude do ponto 2 é␣
,→{int(phi_grau_2)}°{int(phi_minuto_2)}\'{phi_segundo_2:.6f}"')

A latitude do ponto 2 é -22°9'59.589150"

[10]: Nj = a/((1-(e**2)*(sin(phi_rad_2))**2)**(1/2))

[11]: dlamb_j = ((s*sin(azimute_rad))/(Nj*cos(phi_rad_2)))*(1-((s**2)/

,→(6*Nj**2))*((1-(sin(azimute_rad)**2))/(cos(phi_rad_2)**2)))

3
 lamb_rad_2 = lambda_rad + dlamb_j
lamb_grau_2 = lamb_rad_2*(180/pi)
lamb_grau_2_n = fabs(lamb_grau_2)
lamb_minuto_2 = 60*(lamb_grau_2_n-(int(lamb_grau_2_n)))
lamb_segundo_2 = 60*(lamb_minuto_2-(int(lamb_minuto_2)))
print(f'\nA longitude do ponto 2 é␣
,→{int(lamb_grau_2)}°{int(lamb_minuto_2)}\'{lamb_segundo_2:.6f}"')

A longitude do ponto 2 é -50°54'15.414872"

[12]: phi_rad_m = (phi_rad_2 + phi_rad)/2

gama = ((dlamb_j*sin(phi_rad_m))/cos(dphi/2))+((dlamb_j**3)/
,→12)*(((sin(phi_rad_m))/(cos(dphi/2)))-((sin(phi_rad_m))**3)/cos(dphi/2)**3)

contraazimute_rad = azimute_rad + gama + pi

contraazimute = contraazimute_rad*(180/pi)
contraazimute_grau_n = fabs(contraazimute)
contraazimute_minuto = 60*(contraazimute_grau_n-(int(contraazimute_grau_n)))
contraazimute_segundo = 60*(contraazimute_minuto-(int(contraazimute_minuto)))
print(f'\nO contra-azimute é␣
,→{int(contraazimute)}°{int(contraazimute_minuto)}\'{contraazimute_segundo:.

,→6f}"')

O contra-azimute é 275°19'19.583216"
PROBLEMA INVERSO

[13]: phi_rad_m = (phi_rad_2 + phi_rad)/2

gama = ((dlamb_j*sin(phi_rad_m))/cos(dphi/2))+((dlamb_j**3)/
,→12)*(((sin(phi_rad_m))/(cos(dphi/2)))-((sin(phi_rad_m))**3)/cos(dphi/2)**3)

contraazimute_rad = azimute_rad + gama + pi

contraazimute = contraazimute_rad*(180/pi)
contraazimute_grau_n = fabs(contraazimute)
contraazimute_minuto = 60*(contraazimute_grau_n-(int(contraazimute_grau_n)))
contraazimute_segundo = 60*(contraazimute_minuto-(int(contraazimute_minuto)))
print(f'\nO contra-azimute é␣
,→{int(contraazimute)}°{int(contraazimute_minuto)}\'{contraazimute_segundo:.

,→6f}"')

O contra-azimute é 275°19'19.583216"

[14]: azimute_rad_avante = atan(((Nj*dlamb_j*cos(phi_rad_2))/

,→(M*dphi))*(1-((3*e**2*sin(2*phi_rad)*dphi)/(4*(1-e**2*sin(phi_rad)**2)))))

4
 if azimute_rad_avante < 0:
azimute_rad_avante = azimute_rad_avante + pi

azimute_avante = azimute_rad_avante*(180/pi)
azimute_avante_grau_n = fabs(azimute_avante)
azimute_avante_minuto = 60*(azimute_avante_grau_n-(int(azimute_avante_grau_n)))
azimute_avante_segundo = 60*(azimute_avante_minuto-(int(azimute_avante_minuto)))
print(f'\nO azimute a vante é, aproximadamente,␣
,→{int(azimute_avante)}°{int(azimute_avante_minuto)}\'{azimute_avante_segundo:.

,→6f}".')

O azimute a vante é, aproximadamente, 95°24'50.357512".

[15]: s_i = (dphi*M)/(cos(azimute_rad)*(1-((3*e**2*sin(2*phi_rad)*dphi)/

,→(4*(1-e**2*sin(phi_rad)**2)))))

print(f'A distância é {s_i:.2f} m')

A distância é 49177.35 m
PROBLEMA DIRETO (sumário)

[16]: print(f'\nA latitude do ponto 2 é␣

,→{int(phi_grau_2)}°{int(phi_minuto_2)}\'{phi_segundo_2:.6f}"')

print(f'\nA longitude do ponto 2 é␣

,→{int(lamb_grau_2)}°{int(lamb_minuto_2)}\'{lamb_segundo_2:.6f}"')

print(f'\nO contra-azimute é␣
,→{int(contraazimute)}°{int(contraazimute_minuto)}\'{contraazimute_segundo:.

,→6f}"')

A latitude do ponto 2 é -22°9'59.589150"

A longitude do ponto 2 é -50°54'15.414872"

O contra-azimute é 275°19'19.583216"
PROBLEMA INVERSO (sumário)

[19]: print(f'\nO azimute a vante é, aproximadamente,␣

,→{int(azimute_avante)}°{int(azimute_avante_minuto)}\'{azimute_avante_segundo:.

,→6f}"')

print(f'\nA distância é {s_i:.2f} m')

print(f'\nO contra-azimute é␣
,→{int(contraazimute)}°{int(contraazimute_minuto)}\'{contraazimute_segundo:.

,→6f}"')

O azimute a vante é, aproximadamente, 95°24'50.357512"

5
A distância é 49177.35 m

O contra-azimute é 275°19'19.583216"