def test_vincinv_edgecases(self):
lat1 = -32.153892
lon1 = -15.394827
lat2 = -31.587369
lon2 = -13.487739
gdist, az12, az21 = vincinv(lat1, lon1, lat2, lon2)
lon1 = lon1 + 14
lon2 = lon2 + 14
gdist_2, az12_2, az21_2 = vincinv(lat1, lon1, lat2, lon2)
self.assertEqual(gdist, gdist_2)
self.assertEqual(az12, az12_2)
self.assertEqual(az21, az21_2)
def normal_orthometric_correction(lat1, lon1, H1, lat2, lon2, H2):
"""
Computes the normal-orthometric correction based on Heck (2003).
See Standard for New Zealand Vertical Datum 2016, Section 3.3
:param lat1: Latitude at Stn1
:param lon1: Longitude at Stn1
:param H1: Physical Height at Stn1
:param lat2: Latitude at Stn2
:param lon2: longitude at Stn2
:param H2: Physical Height at Stn2
:return: normal-orthometric correction
"""
f_ng = cons.grs80_ngf
m_rad = cons.grs80.meanradius
mid_height = (H1 + H2) / 2
mid_lat = m.radians((lat1 + lat2) / 2)
vinc_inv = gg.vincinv(lat1, lon1, lat2, lon2)
dist = vinc_inv[0]
az = vinc_inv[1]
noc = - f_ng / m_rad * mid_height * m.sin(2.0 * mid_lat) * m.cos(m.radians(az)) * dist
return noc
def test_vincinv(self):
# Flinders Peak
lat1 = hp2dec(-37.57037203)
long1 = hp2dec(144.25295244)
# Buninyong
lat2 = hp2dec(-37.39101561)
long2 = hp2dec(143.55353839)
ell_dist, azimuth1to2, azimuth2to1 = vincinv(lat1, long1, lat2, long2)
self.assertEqual(round(ell_dist, 3), 54972.271)
self.assertEqual(round(dec2hp(azimuth1to2), 6), 306.520537)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
test2 = vincinv(lat1, long1, lat1, long1)
self.assertEqual(test2[0], 0)
self.assertEqual(test2[0], 0)
self.assertEqual(test2[2], 0)
def parse_csv(body):
rows = np.genfromtxt(StringIO(body),
delimiter=',',
dtype='f8, f8, f8, f8',
names=['lat1', 'lon1', 'lat2', 'lon2'])
rows = dms2dd_v(np.array(rows[['lat1', 'lon1', 'lat2', 'lon2']].tolist()))
vincenty_rows = list(
vincinv(*list(coords)) for coords in np.atleast_2d(rows))
return '\n'.join('%12.8f, %12.8f, %12.8f' % tuple(v)
for v in vincenty_rows)
def parse_json(body):
coordinates = json.loads(body)['coords']
# rows = dms2dd_v()
rows = dms2dd_v(
np.array(list(tuple(coords.values()) for coords in coordinates)))
vincenty_rows = list(
vincinv(*list(coords)) for coords in np.atleast_2d(rows))
return {
'vincinv':
tuple(
dict(zip(('el_dist', 'azi1to2', 'azi2to1'), row))
for row in vincenty_rows)
}
def test_vincinv(self):
# Flinders Peak
lat1 = hp2dec(-37.57037203)
lon1 = hp2dec(144.25295244)
lat1_DMS = DMSAngle(-37, 57, 3.7203)
lon1_DMS = DMSAngle(144, 25, 29.5244)
# Buninyong
lat2 = hp2dec(-37.39101561)
lon2 = hp2dec(143.55353839)
lat2_DMS = DMSAngle(-37, 39, 10.1561)
lon2_DMS = DMSAngle(143, 55, 35.3839)
# Test Decimal Degrees Input
ell_dist, azimuth1to2, azimuth2to1 = vincinv(lat1, lon1, lat2, lon2)
self.assertEqual(round(ell_dist, 3), 54972.271)
self.assertEqual(round(dec2hp(azimuth1to2), 6), 306.520537)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
# additional test case:
pl1 = (-29.85, 140.71666666666667)
pl2 = (-29.85, 140.76666666666667)
ell_dist, azimuth1to2, azimuth2to1 = vincinv(pl1[0], pl1[1], pl2[0],
pl2[1])
self.assertEqual(round(ell_dist, 3), 4831.553)
self.assertEqual(round(dec2hp(azimuth1to2), 6), 90.004480)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 269.591520)
test2 = vincinv(lat1, lon1, lat1, lon1)
self.assertEqual(test2, (0, 0, 0))
# Test DMSAngle Input
ell_dist, azimuth1to2, azimuth2to1 = vincinv(lat1_DMS, lon1_DMS,
lat2_DMS, lon2_DMS)
self.assertEqual(round(ell_dist, 3), 54972.271)
self.assertEqual(round(dec2hp(azimuth1to2), 6), 306.520537)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
test2 = vincinv(lat1_DMS, lon1_DMS, lat1_DMS, lon1_DMS)
self.assertEqual(test2, (0, 0, 0))
# Test DDMAngle Input
(ell_dist, azimuth1to2, azimuth2to1) = vincinv(lat1_DMS.ddm(),
lon1_DMS.ddm(),
lat2_DMS.ddm(),
lon2_DMS.ddm())
self.assertEqual(round(ell_dist, 3), 54972.271)
self.assertEqual(round(dec2hp(azimuth1to2), 6), 306.520537)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
test2 = vincinv(lat1_DMS.ddm(), lon1_DMS.ddm(), lat1_DMS.ddm(),
lon1_DMS.ddm())
self.assertEqual(test2, (0, 0, 0))
def test_equality_vincentys(self):
# Test multiple point-to-point vincinv calculations
abs_path = os.path.abspath(os.path.dirname(__file__))
test_geo_coords =\
np.genfromtxt(os.path.join(abs_path,
'resources/Test_Conversion_Geo.csv'),
delimiter=',',
dtype='S4,f8,f8',
names=['site', 'lat1', 'long1'],
usecols=('lat1', 'long1'))
test_geo_coord2 = \
np.genfromtxt(os.path.join(abs_path,
'resources/Test_Conversion_Geo.csv'),
delimiter=',',
dtype='S4,f8,f8',
names=['site', 'lat2', 'long2'],
usecols=('lat2', 'long2'))
# Form array with point pairs from test file
test_pairs = rfn.merge_arrays(
[test_geo_coords, np.roll(test_geo_coord2, 1)], flatten=True)
# Calculate Vincenty's Inverse Result using Lat, Long Pairs
vincinv_result = np.array(
list(
vincinv(*x)
for x in test_pairs[['lat1', 'long1', 'lat2', 'long2']]))
# Calculate Vincenty's Direct Result using Results from Inverse Function
vincdir_input = rfn.merge_arrays(
[test_geo_coords, vincinv_result[:, 1], vincinv_result[:, 0]],
flatten=True)
vincdir_input.dtype.names = ['lat1', 'long1', 'az1to2', 'ell_dist']
vincdir_result = np.array(
list(
vincdir(*x) for x in vincdir_input[
['lat1', 'long1', 'az1to2', 'ell_dist']]))
np.testing.assert_almost_equal(test_pairs['lat2'],
vincdir_result[:, 0],
decimal=8)
np.testing.assert_almost_equal(test_pairs['long2'],
vincdir_result[:, 1],
decimal=8)
np.testing.assert_almost_equal(vincinv_result[:, 2], vincdir_result[:,
2])
def handle_vincinv():
from_angle_type = request.args.get('from_angle_type', default='dd')
to_angle_type = request.args.get('to_angle_type', default='dd')
lat1 = request.args.get('lat1', type=float)
lon1 = request.args.get('lon1', type=float)
lat2 = request.args.get('lat2', type=float)
lon2 = request.args.get('lon2', type=float)
dd = angle_type_to_dd[from_angle_type]
lat1_dd, lon1_dd, lat2_dd, lon2_dd = dd(lat1), dd(lon1), dd(lat2), dd(lon2)
ell_dist, azimuth1to2_dd, azimuth2to1_dd = vincinv(lat1_dd, lon1_dd,
lat2_dd, lon2_dd)
angle = dd_to_angle_type[to_angle_type]
azimuth1to2, azimuth2to1 = angle(azimuth1to2_dd), angle(azimuth2to1_dd)
return jsonify({
'ell_dist': ell_dist,
'azimuth1to2': azimuth1to2,
'azimuth2to1': azimuth2to1
}), 200
if 'SecondStdDevSetupStyle' in m:
c = sd_styl[m['SecondStdDevSetupStyle']]['CentringStdDev']
v = sd_styl[m['SecondStdDevSetupStyle']]['VtStdDev']
to_sd[0, 0] = (c)**2 / float(m['Lscale'])
to_sd[1, 1] = (c)**2 / float(m['Pscale'])
to_sd[2, 2] = (v)**2 / float(m['Hscale'])
to_sd = to_sd / float(m['Vscale'])
# Sum the 3 matricies and test against orig
cal_enu = orig_enu + at_sd + to_sd
# find and apply any StdDevObsStyle styling templates
s = ''
if 'StdDevObsStyle' in m:
dis = vincinv(at_lat, at_lng, to_lat, to_lng)
enu = np.zeros([3, 3])
s = obs_styl[m['StdDevObsStyle']]
enu[0, 0] = ((s['HzConstant']) + dis[0] *
(s['HzPPM']) * 10E-6)**2
enu[1, 1] = ((s['HzConstant']) + dis[0] *
(s['HzPPM']) * 10E-6)**2
enu[2, 2] = ((s['VtConstant']) + dis[0] *
(s['VtPPM']) * 10E-6)**2
enu = enu / float(m['Vscale'])
enu[0, 0] = enu[0, 0] / float(m['Lscale'])
enu[1, 1] = enu[1, 1] / float(m['Pscale'])
enu[2, 2] = enu[2, 2] / float(m['Hscale'])
if 'IncreaseReduce' in s:
if (s['IncreaseOrReduce'] == 'Increase'
'X': x,
'Y': y,
'Z': z
}
if c < 0: c += 1
###########################################################################
# Analyse vector agreement of NGCA Vs APREF #
###########################################################################
best_sum = 0
prev_best = 1000000000000000000
all_joins = []
for s1 in apref:
for s2 in apref:
if s1 != s2:
NGCA_dis, NGCA_az, RvAz = vincinv(ngca[s1]['P'], ngca[s1]['L'],
ngca[s2]['P'], ngca[s2]['L'])
APREF_dis, APREF_az, RvAz = vincinv(apref[s1]['P'],
apref[s1]['L'],
apref[s2]['P'],
apref[s2]['L'])
dif_dis = NGCA_dis - APREF_dis
dif_Az = tan(radians(NGCA_az - APREF_az)) * APREF_dis
dif_ht = ((apref[s2]['EHGT'] - apref[s1]['EHGT']) -
(ngca[s2]['EHGT'] - ngca[s1]['EHGT']))
best_sum = best_sum + dif_dis
all_joins = all_joins + [[
s1, s2, apref[s1]['P'], apref[s1]['L'], apref[s2]['P'],
apref[s2]['L'],
round(dif_dis, 4),
round(dif_Az, 4),
round(dif_Az, 4)
def gnss_xyz2dah(coords, xyz_bases):
dah_bases = {}
print(' Calculating baseline transformations ')
for b in xyz_bases:
f_x, f_y, f_z = llh2xyz(coords[xyz_bases[b]['first']]['LAT'],
coords[xyz_bases[b]['first']]['LON'],
coords[xyz_bases[b]['first']]['EHGT'])
Calc_point_x = f_x + xyz_bases[b]['dX']
Calc_point_y = f_y + xyz_bases[b]['dY']
Calc_point_z = f_z + xyz_bases[b]['dZ']
p, l, h = xyz2llh(Calc_point_x, Calc_point_y, Calc_point_z)
e_dist, b_az, b_rev_az = vincinv(coords[xyz_bases[b]['first']]['LAT'],
coords[xyz_bases[b]['first']]['LON'],
p, l)
adj_dist, adj_az, b_rev_az = vincinv(
coords[xyz_bases[b]['first']]['LAT'],
coords[xyz_bases[b]['first']]['LON'],
coords[xyz_bases[b]['second']]['LAT'],
coords[xyz_bases[b]['second']]['LON'])
e_dist_res = adj_dist - e_dist
b_az_res = adj_az - b_az
e_ht_diff = h - coords[xyz_bases[b]['first']]['EHGT']
n1 = coords[xyz_bases[b]['first']]['OHGT'] - coords[xyz_bases[b]
['first']]['EHGT']
n2 = coords[xyz_bases[b]['second']]['OHGT'] - coords[
xyz_bases[b]['second']]['EHGT']
o_ht_diff = -1 * n1 + e_ht_diff + n2
o_ht_diff_res = (coords[xyz_bases[b]['second']]['OHGT'] -
coords[xyz_bases[b]['first']]['OHGT']) - o_ht_diff
#transfor the baseline to distance, azimuth, up
#translated code from http://peas13.dli.wa.gov.au/svn-intsvc/Delphi/GesmarComponents/trunk/Geodetic.pas
m_lat = (coords[xyz_bases[b]['first']]['LAT'] + p) / 2
m_x = (f_x + Calc_point_x) / 2
m_y = (f_y + Calc_point_y) / 2
dR = sqrt(m_x * m_x + m_y * m_y)
dE2 = grs80.ecc1sq
dQ = radians(m_lat)
sinQ = sin(dQ)
dTemp = sqrt(1.0 - dE2 * sinQ * sinQ)
dN = grs80.semimaj / dTemp
dM = dN * ((1.0 - dE2) / (dTemp * dTemp))
sinQ = sin(dQ)
cosQ = cos(dQ)
secQ = 1.0 / cosQ
dF = grs80.f
dE2 = 2 * dF - (dF * dF)
dA = m_x * tan(dQ) / (dR * dR * (dE2 - secQ * secQ))
dB = 1.0 / (dR * secQ * secQ - dE2 * dN * cosQ)
dC = dR * sinQ / (cosQ * cosQ) - dN * dE2 * sinQ * cosQ / (
1.0 - dE2 * sinQ * sinQ)
JMatrix = np.zeros([3, 3])
JMatrix[0, 0] = dM * dA
JMatrix[0, 1] = dM * (m_y * dA / m_x)
JMatrix[0, 2] = dM * dB
JMatrix[1, 0] = -(dN * cosQ) * m_y / (dR * dR)
JMatrix[1, 1] = (dN * cosQ) * m_x / (dR * dR)
JMatrix[1, 2] = 0.0
JMatrix[2, 0] = m_x / (dR * cosQ) + dA * dC
JMatrix[2, 1] = m_y / (dR * cosQ) + m_y * dA * dC / m_x
JMatrix[2, 2] = dB * dC
b_var_matrix = np.zeros([3, 3])
b_var_matrix[0, 0] = xyz_bases[b]['sdev_x']**2
b_var_matrix[1, 1] = xyz_bases[b]['sdev_y']**2
b_var_matrix[2, 2] = xyz_bases[b]['sdev_z']**2
b_nst_matrix = np.zeros([3, 3])
b_nst_matrix[0, 0] = xyz_bases[b]['nstat_x']**2
b_nst_matrix[1, 1] = xyz_bases[b]['nstat_y']**2
b_nst_matrix[2, 2] = xyz_bases[b]['nstat_z']**2
cosAz = cos(radians(b_az))
sinAz = sin(radians(b_az))
AMatrix = np.zeros([3, 3])
AMatrix[0, 0] = cosAz
AMatrix[0, 1] = sinAz
if e_dist == 0:
AMatrix[1, 0] = degrees(sinAz / 0.00001)
AMatrix[1, 1] = -degrees(cosAz / 0.00001)
else:
AMatrix[1, 0] = degrees(sinAz / e_dist)
AMatrix[1, 1] = -degrees(cosAz / e_dist)
GMatrix = np.matmul(np.matmul(JMatrix, b_var_matrix),
JMatrix.transpose())
dah_Matrix = np.matmul(np.matmul(AMatrix, GMatrix),
AMatrix.transpose())
n_GMatrix = np.matmul(np.matmul(JMatrix, b_nst_matrix),
JMatrix.transpose())
nstat_Matrix = np.matmul(np.matmul(AMatrix, n_GMatrix),
AMatrix.transpose())
dah_bases[b] = {
'first': xyz_bases[b]['first'],
'second': xyz_bases[b]['second'],
'dX': xyz_bases[b]['dX'],
'dY': xyz_bases[b]['dY'],
'dZ': xyz_bases[b]['dZ'],
'e_dist': e_dist,
'e_dist_res': e_dist_res,
'e_dist_sdev': sqrt(abs(dah_Matrix[0, 0])),
'e_dist_nstat': sqrt(abs(nstat_Matrix[0, 0])),
'b_az': b_az,
'b_az_res': b_az_res,
'b_az_sdev': sqrt(abs(dah_Matrix[1, 1])),
'b_az_nstat': sqrt(abs(sin(radians(nstat_Matrix[1, 1])) * e_dist)),
'o_ht_diff': o_ht_diff,
'e_ht_diff': e_ht_diff,
'o_ht_diff_res': o_ht_diff_res,
'e_ht_diff_sdev': sqrt(abs(GMatrix[2, 2])),
'e_ht_diff_nstat': sqrt(abs(n_GMatrix[2, 2]))
}
return coords, dah_bases
