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