def test_llh2xyz(self):
# Test of single point
x, y, z = llh2xyz(hp2dec(-37.482667598), hp2dec(144.581644114),
39.6514)
self.assertAlmostEqual(x, -4131654.2815, 3)
self.assertAlmostEqual(y, 2896107.9738, 3)
self.assertAlmostEqual(z, -3888601.3067, 3)
# Test DMSAngle input
x, y, z = llh2xyz(DMSAngle(-37, 48, 26.67598),
DMSAngle(144, 58, 16.44114), 39.6514)
self.assertAlmostEqual(x, -4131654.2815, 3)
self.assertAlmostEqual(y, 2896107.9738, 3)
self.assertAlmostEqual(z, -3888601.3067, 3)
# Test DDMAngle input
x, y, z = llh2xyz(DDMAngle(-37, 48.4445996), DDMAngle(144, 58.274019),
39.6514)
self.assertAlmostEqual(x, -4131654.2815, 3)
self.assertAlmostEqual(y, 2896107.9738, 3)
self.assertAlmostEqual(z, -3888601.3067, 3)
# Tests comparing results from DynAdjust Adjusted Coordinate File
# including 109 Points Across Australia
abs_path = os.path.abspath(os.path.dirname(__file__))
testdata = read_dnacoord(
os.path.join(abs_path, 'resources/natadjust_rvs_example.dat'))
for coord in testdata:
coord.converthptodd()
xcomp, ycomp, zcomp = llh2xyz(coord.lat, coord.long, coord.ell_ht)
assert (abs(coord.x - xcomp) < 2e-4)
assert (abs(coord.y - ycomp) < 2e-4)
assert (abs(coord.z - zcomp) < 2e-4)
def changeface(self):
# Change Horizontal Angle
if 0 <= self.hz_obs.degree < 180:
hz_switch = self.hz_obs + DMSAngle(180)
elif 180 <= self.hz_obs.degree < 360:
hz_switch = self.hz_obs - DMSAngle(180)
else:
raise ValueError('Horizontal Angle out of range (0 to 360 degrees)')
# Change Vertical Angle
if 0 <= self.va_obs.degree < 360:
va_switch = DMSAngle(360) - self.va_obs
else:
raise ValueError('Vertical Angle out of range (0 to 360 degrees)')
# Change Face Label
newface = None
if self.face == 'FL':
newface = 'FR'
elif self.face == 'FR':
newface = 'FL'
return Observation(self.from_id,
self.to_id,
self.inst_height,
self.target_height,
newface,
self.rounds,
hz_switch,
self.hz_stdev,
va_switch,
self.va_stdev,
self.sd_obs,
self.sd_stdev,
self.hz_dist,
self.vert_dist)
def test_vincdir(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)
# To Buninyong
azimuth1to2 = hp2dec(306.520537)
azimuth1to2_DMS = DMSAngle(306, 52, 5.37)
ell_dist = 54972.271
# Test Decimal Degrees Input
lat2, lon2, azimuth2to1 = vincdir(lat1, lon1, azimuth1to2, ell_dist)
self.assertEqual(round(dec2hp(lat2), 8), -37.39101561)
self.assertEqual(round(dec2hp(lon2), 8), 143.55353839)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
# Test DMSAngle Input
lat2, long2, azimuth2to1 = vincdir(lat1_DMS, lon1_DMS, azimuth1to2_DMS,
ell_dist)
self.assertEqual(round(dec2hp(lat2), 8), -37.39101561)
self.assertEqual(round(dec2hp(long2), 8), 143.55353839)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
# Test DDMAngle Input
lat2, long2, azimuth2to1 = vincdir(lat1_DMS.ddm(), lon1_DMS.ddm(),
azimuth1to2_DMS.ddm(), ell_dist)
self.assertEqual(round(dec2hp(lat2), 8), -37.39101561)
self.assertEqual(round(dec2hp(long2), 8), 143.55353839)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
def test_radiations(self):
test1 = radiations(500, 500,
DMSAngle(290, 13).dec(), 44.620,
DMSAngle(2, 18, 35).dec(), 1.002515)
self.assertAlmostEqual(test1[0], 458.681, 3)
self.assertAlmostEqual(test1[1], 517.137, 3)
test2 = radiations(500, 500, DMSAngle(290, 13).dec(), 44.620)
self.assertAlmostEqual(test2[0], 458.129, 3)
self.assertAlmostEqual(test2[1], 515.419, 3)
test3 = radiations(564.747, 546.148,
DMSAngle(41, 7).dec(), 27.720,
DMSAngle(2, 18, 35).dec(), 1.002515)
self.assertAlmostEqual(test3[0], 583.850, 3)
self.assertAlmostEqual(test3[1], 566.331, 3)
def test_vincdir_utm(self):
# Flinders Peak (UTM 55)
zone1 = 55
east1 = 273741.2966
north1 = 5796489.7769
# Grid Dimensions to Point 2 (Buninyong)
grid_dist = 54992.279
grid1to2 = hp2dec(305.17017259)
grid1to2_DMS = DMSAngle(305, 17, 1.7259)
# Test Decimal Degrees Input
(zone2, east2, north2, grid2to1,
lsf) = vincdir_utm(zone1, east1, north1, grid1to2, grid_dist)
self.assertEqual(zone2, zone1)
self.assertAlmostEqual(east2, 228854.0513, 3)
self.assertAlmostEqual(north2, 5828259.0384, 3)
self.assertAlmostEqual(dec2hp(grid2to1), 125.17418518, 7)
self.assertAlmostEqual(lsf, 1.00036397, 8)
# Test DMSAngle Input
(zone2, east2, north2, grid2to1,
lsf) = vincdir_utm(zone1, east1, north1, grid1to2_DMS, grid_dist)
self.assertEqual(zone2, zone1)
self.assertAlmostEqual(east2, 228854.0513, 3)
self.assertAlmostEqual(north2, 5828259.0384, 3)
self.assertAlmostEqual(dec2hp(grid2to1), 125.17418518, 7)
self.assertAlmostEqual(lsf, 1.00036397, 8)
def test_geo2grid(self):
abs_path = os.path.abspath(os.path.dirname(__file__))
# Test various coordinates in Australia
testdata = read_dnacoord(
os.path.join(abs_path, 'resources/natadjust_rvs_example.dat'))
for coord in testdata:
coord.converthptodd()
hem, zonecomp, eastcomp, northcomp, psf, grid_conv = geo2grid(
coord.lat, coord.long)
self.assertEqual(zonecomp, coord.zone)
self.assertLess(abs(eastcomp - coord.easting), 4e-4)
self.assertLess((northcomp - coord.northing), 4e-4)
# Test North and South Hemisphere Output
north_ex = (DMSAngle(34, 57,
00.79653).dec(), DMSAngle(117, 48,
36.68783).dec())
south_ex = (DMSAngle(-34, 57,
00.79653).dec(), DMSAngle(117, 48,
36.68783).dec())
north_grid = geo2grid(north_ex[0], north_ex[1])
south_grid = geo2grid(south_ex[0], south_ex[1])
self.assertEqual(north_grid[0], 'North')
self.assertEqual(south_grid[0], 'South')
self.assertEqual(north_grid[1], south_grid[1]) # Zone
self.assertEqual(north_grid[2], south_grid[2]) # Easting
self.assertEqual(north_grid[3], 10000000 - south_grid[3]) # Northing
self.assertEqual(north_grid[4], south_grid[4]) # PSF
self.assertEqual(north_grid[5], -south_grid[5]) # Grid Convergence
# Test Input Validation
with self.assertRaises(ValueError):
geo2grid(0, 45, -1)
with self.assertRaises(ValueError):
geo2grid(0, 45, 61)
with self.assertRaises(ValueError):
geo2grid(-81, 45, 0)
with self.assertRaises(ValueError):
geo2grid(85, 45, 0)
with self.assertRaises(ValueError):
geo2grid(0, -181, 0)
with self.assertRaises(ValueError):
geo2grid(0, 181, 0)
def __init__(self, from_id, to_id, inst_height=0.0, target_height=0.0,
face='FL', rounds=0.5,
hz_obs=DMSAngle(0, 0, 0), hz_stdev=DMSAngle(0, 0, 0),
va_obs=DMSAngle(0, 0, 0), va_stdev=DMSAngle(0, 0, 0),
sd_obs=0.0, sd_stdev=0.0,
hz_dist=0.0, vert_dist=0.0):
self.from_id = from_id
self.to_id = to_id
self.inst_height = inst_height
self.target_height = target_height
self.face = face
self.rounds = rounds
self.hz_obs = hz_obs
self.hz_stdev = hz_stdev
self.va_obs = va_obs
self.va_stdev = va_stdev
self.sd_obs = sd_obs
self.sd_stdev = sd_stdev
self.hz_dist = hz_dist
self.vert_dist = vert_dist
def parse_vert(gsi_line):
dms = readgsiword16(gsi_line, '22.324') / 100000
degmin, seconds = divmod(abs(dms) * 1000, 10)
degrees, minutes = divmod(degmin, 100)
if 0 < degrees <= 180:
face = 'FL'
elif 180 < degrees <= 360:
face = 'FR'
else:
face = 'FL'
return face, DMSAngle(degrees, minutes, seconds * 10)
def test_vincdir_utm(self):
# Flinders Peak (UTM)
zone1 = 55
east1 = 273741.2966
north1 = 5796489.7769
# To Buninyong
azimuth1to2 = hp2dec(306.520537)
azimuth1to2_DMS = DMSAngle(306, 52, 5.37)
ell_dist = 54972.271
# Test Decimal Degrees Input
(hemisphere2, zone2, east2,
north2, azimuth2to1) = vincdir_utm(zone1, east1, north1,
azimuth1to2, ell_dist)
self.assertEqual(hemisphere2, 'South')
self.assertEqual(zone2, 54)
self.assertEqual(round(east2, 4), 758173.7968)
self.assertEqual(round(north2, 4), 5828674.3395)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
# Test DMSAngle Input
(hemisphere2, zone2, east2,
north2, azimuth2to1) = vincdir_utm(zone1, east1, north1,
azimuth1to2_DMS, ell_dist)
self.assertEqual(hemisphere2, 'South')
self.assertEqual(zone2, 54)
self.assertEqual(round(east2, 4), 758173.7968)
self.assertEqual(round(north2, 4), 5828674.3395)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
# Test DDMAngle Input
(hemisphere2, zone2, east2,
north2, azimuth2to1) = vincdir_utm(zone1, east1, north1,
azimuth1to2_DMS.ddm(), ell_dist)
self.assertEqual(hemisphere2, 'South')
self.assertEqual(zone2, 54)
self.assertEqual(round(east2, 4), 758173.7968)
self.assertEqual(round(north2, 4), 5828674.3395)
self.assertEqual(round(dec2hp(azimuth2to1), 6), 127.102507)
def test_geo2grid(self):
# Single Point Test
hem, zone, east, north, psf, grid_conv = geo2grid(
hp2dec(-37.482667598), hp2dec(144.581644114))
self.assertEqual(hem, 'South')
self.assertEqual(zone, 55)
self.assertAlmostEqual(east, 321405.5592, 3)
self.assertAlmostEqual(north, 5813614.1613, 3)
self.assertAlmostEqual(psf, 0.99999287, 8)
self.assertAlmostEqual(grid_conv, -1.2439811331, 9)
# Test DMSAngle Input
(hem, zone, east, north, psf,
grid_conv) = geo2grid(DMSAngle(-37, 48, 26.67598),
DMSAngle(144, 58, 16.44114))
self.assertEqual(hem, 'South')
self.assertEqual(zone, 55)
self.assertAlmostEqual(east, 321405.5592, 3)
self.assertAlmostEqual(north, 5813614.1613, 3)
self.assertAlmostEqual(psf, 0.99999287, 8)
self.assertAlmostEqual(grid_conv, -1.2439811331, 9)
# Test DDMAngle Input
(hem, zone, east, north, psf,
grid_conv) = geo2grid(DDMAngle(-37, 48.4445997),
DDMAngle(144, 58.274019))
self.assertEqual(hem, 'South')
self.assertEqual(zone, 55)
self.assertAlmostEqual(east, 321405.5592, 3)
self.assertAlmostEqual(north, 5813614.1613, 3)
self.assertAlmostEqual(psf, 0.99999287, 8)
self.assertAlmostEqual(grid_conv, -1.2439811331, 9)
abs_path = os.path.abspath(os.path.dirname(__file__))
# Test various coordinates in Australia
testdata = read_dnacoord(
os.path.join(abs_path, 'resources/natadjust_rvs_example.dat'))
for coord in testdata:
coord.converthptodd()
hem, zonecomp, eastcomp, northcomp, psf, grid_conv = geo2grid(
coord.lat, coord.long)
self.assertEqual(zonecomp, coord.zone)
self.assertLess(abs(eastcomp - coord.easting), 4e-4)
self.assertLess((northcomp - coord.northing), 4e-4)
# Test North and South Hemisphere Output
north_ex = (DMSAngle(34, 57,
00.79653).dec(), DMSAngle(117, 48,
36.68783).dec())
south_ex = (DMSAngle(-34, 57,
00.79653).dec(), DMSAngle(117, 48,
36.68783).dec())
north_grid = geo2grid(north_ex[0], north_ex[1])
south_grid = geo2grid(south_ex[0], south_ex[1])
self.assertEqual(north_grid[0], 'North')
self.assertEqual(south_grid[0], 'South')
self.assertEqual(north_grid[1], south_grid[1]) # Zone
self.assertEqual(north_grid[2], south_grid[2]) # Easting
self.assertEqual(north_grid[3], 10000000 - south_grid[3]) # Northing
self.assertEqual(north_grid[4], south_grid[4]) # PSF
self.assertEqual(north_grid[5], -south_grid[5]) # Grid Convergence
# Test Input Validation
with self.assertRaises(ValueError):
geo2grid(0, 45, -1)
with self.assertRaises(ValueError):
geo2grid(0, 45, 61)
with self.assertRaises(ValueError):
geo2grid(-81, 45, 0)
with self.assertRaises(ValueError):
geo2grid(85, 45, 0)
with self.assertRaises(ValueError):
geo2grid(0, -181, 0)
with self.assertRaises(ValueError):
geo2grid(0, 181, 0)
def parse_hz(gsi_line):
dms = readgsiword16(gsi_line, '21.324') / 100000
degmin, second = divmod(abs(dms) * 1000, 10)
degree, minute = divmod(degmin, 100)
return DMSAngle(degree, minute, second * 10)
def test_DMSAngle(self):
# Test DMSAngle Methods
self.assertEqual(dec_ex, dms_ex.dec())
self.assertEqual(hp_ex, dms_ex.hp())
self.assertEqual(hp_ex3, dms_ex3.hp())
self.assertEqual(ddm_ex, dms_ex.ddm())
self.assertEqual(-ddm_ex, -dms_ex.ddm())
self.assertEqual(ddm_ex3, dms_ex3.ddm())
# Test DMSAngle Sign Conventions
self.assertEqual(
-dec_ex,
DMSAngle(-dms_ex.degree, dms_ex.minute, dms_ex.second).dec())
self.assertEqual(
dec_ex,
DMSAngle(dms_ex.degree, -dms_ex.minute, -dms_ex.second).dec())
self.assertAlmostEqual(
-dec_ex4,
DMSAngle(0, -dms_ex4.minute, dms_ex4.second).dec(), 9)
self.assertAlmostEqual(
dec_ex4,
DMSAngle(0, dms_ex4.minute, dms_ex4.second).dec(), 9)
self.assertEqual(-dec_ex5, DMSAngle(0, 0, -dms_ex5.second).dec())
self.assertEqual(dec_ex5, DMSAngle(0, 0, dms_ex5.second).dec())
self.assertEqual(-dms_ex3, DMSAngle(12, 34, -30))
self.assertEqual(dms_ex.sign, 1)
self.assertEqual(-dms_ex.sign, -1)
self.assertEqual(dms_ex4.sign, 1)
self.assertEqual(-dms_ex4.sign, -1)
self.assertEqual(dms_ex5.sign, 1)
self.assertEqual(-dms_ex5.sign, -1)
self.assertEqual(DMSAngle(-1, 2, 3).sign, -1)
self.assertEqual(DMSAngle(1, -2, 3).sign, 1)
self.assertEqual(DMSAngle(1, 2, -3).sign, 1)
self.assertEqual(DMSAngle(0, -1, 2).sign, -1)
self.assertEqual(DMSAngle(0, 0, -3).sign, -1)
self.assertEqual(DMSAngle(-0, 1, 2).sign, 1)
self.assertEqual(DMSAngle(-0.0, 1, 2).sign, -1)
self.assertEqual(repr(dms_ex), '{DMSAngle: +123d 44m 55.5s}')
self.assertEqual(repr(dms_ex3), '{DMSAngle: -12d 34m 30s}')
# Test DMSAngle Overloads
self.assertEqual(dec_ex + dec_ex2, (dms_ex + dms_ex2).dec())
self.assertEqual(dec_ex2 + dec_ex, (dms_ex2 + dms_ex).dec())
self.assertEqual(dec_ex - dec_ex2, (dms_ex - dms_ex2).dec())
self.assertEqual(dec_ex2 - dec_ex, (dms_ex2 - dms_ex).dec())
self.assertEqual(dec_ex * 5, (dms_ex * 5).dec())
self.assertEqual(5 * dec_ex, (5 * dms_ex).dec())
self.assertEqual(dec_ex / 3, (dms_ex / 3).dec())
self.assertEqual(abs(-dms_ex), dms_ex)
self.assertEqual(-dms_ex2, dms_ex3)
self.assertEqual(dms_ex2, abs(dms_ex3))
self.assertEqual(dms_ex, ddm_ex)
self.assertTrue(dms_ex == dms_ex)
self.assertFalse(dms_ex == dms_ex2)
self.assertTrue(dms_ex != dms_ex2)
self.assertFalse(dms_ex != dms_ex)
self.assertTrue(dms_ex > dms_ex2)
self.assertFalse(dms_ex2 > dms_ex)
self.assertTrue(dms_ex2 < dms_ex)
self.assertFalse(dms_ex < dms_ex2)
with self.assertRaises(TypeError):
dms_ex * 'a'
with self.assertRaises(TypeError):
'a' * dms_ex
with self.assertRaises(TypeError):
dms_ex / 'a'
with self.assertRaises(TypeError):
dms_ex + 'a'
with self.assertRaises(TypeError):
'a' + dms_ex
with self.assertRaises(TypeError):
dms_ex - 'a'
with self.assertRaises(TypeError):
'a' - dms_ex
# Test Class Interoperability
self.assertEqual(DMSAngle(1, 2, 3) + DDMAngle(2, 3), DMSAngle(3, 5, 3))
self.assertEqual(
DMSAngle(3, 2, 0) - DDMAngle(2, 2.5), DMSAngle(0, 59, 30))
self.assertEqual(DDMAngle(2, 3) + DMSAngle(1, 2, 3), DDMAngle(3, 5.05))
self.assertEqual(
DDMAngle(3, 2) - DMSAngle(2, 2, 30), DDMAngle(0, 59.5))
def gsi2class(gsi_list):
"""
Takes a list where first entry is station record and
all remaining records are observations and creates
a InstSetup Object with Observation Objects included.
:param gsi_list:
:return:
"""
def readgsiword16(linestring, word_id):
try:
wordstart = str.find(linestring, word_id)
if wordstart == -1:
raise ValueError
except ValueError:
print('ValueError: GSI record type ' + word_id + ' not found\n'
'Line Data: ' + linestring)
return None
word_val = linestring[(wordstart + 7):(wordstart + 23)]
word_val = word_val.lstrip('0')
if word_val == '':
return 0
else:
return int(word_val)
def parse_ptid(gsi_line):
ptid = gsi_line[8:24]
ptid = ptid.lstrip('0')
return ptid
def parse_easting(gsi_line):
return (readgsiword16(gsi_line, '84..')) / 10000
def parse_northing(gsi_line):
return (readgsiword16(gsi_line, '85..')) / 10000
def parse_elev(gsi_line):
return (readgsiword16(gsi_line, '86..')) / 10000
def parse_hz(gsi_line):
dms = readgsiword16(gsi_line, '21.324') / 100000
degmin, second = divmod(abs(dms) * 1000, 10)
degree, minute = divmod(degmin, 100)
return DMSAngle(degree, minute, second * 10)
def parse_slope(gsi_line):
return (readgsiword16(gsi_line, '31..')) / 10000
def parse_dist(gsi_line):
return (readgsiword16(gsi_line, '32..')) / 10000
def parse_tgtht(gsi_line):
return (readgsiword16(gsi_line, '87..')) / 10000
def parse_instht(gsi_line):
return (readgsiword16(gsi_line, '88..')) / 10000
def parse_vert(gsi_line):
dms = readgsiword16(gsi_line, '22.324') / 100000
degmin, seconds = divmod(abs(dms) * 1000, 10)
degrees, minutes = divmod(degmin, 100)
if 0 < degrees <= 180:
face = 'FL'
elif 180 < degrees <= 360:
face = 'FR'
else:
face = 'FL'
return face, DMSAngle(degrees, minutes, seconds * 10)
gsi_project = []
for record in gsi_list:
from_stn = parse_ptid(record[0])
obs_list = []
for line in record:
if '31..' in line:
to_stn = parse_ptid(line)
hz = parse_hz(line)
hz_stdev = DMSAngle(0)
face, vert = parse_vert(line)
va_stdev = DMSAngle(0)
rounds = 0.5
slope = parse_slope(line)
sd_stdev = 0.0
tgtht = parse_tgtht(line)
instht = parse_instht(line)
obs = Observation(from_stn, to_stn, instht, tgtht, face,
rounds, hz, hz_stdev, vert, va_stdev, slope,
sd_stdev)
obs_list.append(obs)
if '84..' in record[0]:
pt_id = parse_ptid(record[0])
easting = parse_easting(record[0])
northing = parse_northing(record[0])
elev = parse_elev(record[0])
coord = Coordinate(pt_id, 'utm', 'gda94', 'gda94', '2018.1',
easting, northing, elev)
setup = InstSetup(pt_id, coord)
for i in range(0, len(obs_list)):
setup.addobs(obs_list[i])
gsi_project.append(setup)
return gsi_project
import unittest
from geodepy.convert import dec2hp, hp2dec, DMSAngle, DDMAngle, dec2dms, dec2ddm, hp2dms, hp2ddm, dd2dms
dec_ex = 123.74875
dec_ex2 = 12.575
dec_ex3 = -12.575
dec_ex4 = 0.0525
dec_ex5 = 0.005
hp_ex = 123.44555
hp_ex2 = 12.3430
hp_ex3 = -12.3430
hp_ex4 = 0.0309
hp_ex5 = 0.0018
dms_ex = DMSAngle(123, 44, 55.5)
dms_ex2 = DMSAngle(12, 34, 30)
dms_ex3 = DMSAngle(-12, -34, -30)
dms_ex4 = DMSAngle(0, 3, 9)
dms_ex5 = DMSAngle(0, 0, 18)
ddm_ex = DDMAngle(123, 44.925)
ddm_ex2 = DDMAngle(12, 34.5)
ddm_ex3 = DDMAngle(-12, -34.5)
ddm_ex4 = DDMAngle(0, 3.15)
ddm_ex5 = DDMAngle(0, 0.3)
class TestConvert(unittest.TestCase):
def test_dec2hp(self):
self.assertAlmostEqual(hp_ex, dec2hp(dec_ex), 13)
def meanfaces(ob1, ob2):
"""
Take two Observations and return their mean Face Left Sense Observation
If one Observation and one None, return Face Left Sense Observation
:param ob1: Observation Object (or None)
:param ob2: Observation Object (or None)
:return: Meaned Observation Object of ob1 and ob2 (Face Left Sense)
"""
if isinstance(ob1, Observation) and isinstance(ob1, type(None)):
raise TypeError('Invalid Input Type (ob1)')
elif isinstance(ob2, Observation) and isinstance(ob2, type(None)):
raise TypeError('Invalid Input Type (ob2)')
elif isinstance(ob1, type(None)) and isinstance(ob2, type(None)):
raise TypeError('Ob1 and Ob2 cannot both be None')
elif isinstance(ob1, type(None)) and isinstance(ob2, Observation):
if ob2.face == 'FL':
return ob2
else:
return ob2.changeface()
elif isinstance(ob1, Observation) and isinstance(ob2, type(None)):
if ob1.face == 'FL':
return ob1
else:
return ob1.changeface()
elif (ob1.from_id != ob2.from_id
or ob1.to_id != ob2.to_id
or ob1.inst_height != ob2.inst_height
or ob1.target_height != ob2.target_height):
raise ValueError('Inputs must be Observation Objects. '
'From, To, Instrument and Target Height must be the same to mean two observations\n' +
'Observation 1\n' +
'from: ' + ob1.from_id + ' to: ' + ob1.to_id + ' inst_ht: ' + str(ob1.inst_height)
+ ' tgt_ht: ' + str(ob1.target_height) + '\n' +
'Observation 2\n' +
'from: ' + ob2.from_id + ' to: ' + ob2.to_id + ' inst_ht: ' + str(ob2.inst_height)
+ ' tgt_ht: ' + str(ob2.target_height) + '\n')
else:
# Check Face Inputs, convert all to Face Left Sense
if ob1.face == 'FL' and ob2.face == 'FR':
ob2 = ob2.changeface()
elif ob1.face == 'FR' and ob2.face == 'FL':
ob1 = ob1.changeface()
elif ob1.face == 'FR' and ob2.face == 'FR':
ob1 = ob1.changeface()
ob2 = ob2.changeface()
elif ob1.face == 'FL' and ob2.face == 'FL':
pass
else:
raise ValueError('Incompatible Face Values')
# Calculate means, return new observation
if abs(ob1.hz_obs.dec() - ob2.hz_obs.dec()) < 180:
meaned_hz = (ob1.hz_obs + ob2.hz_obs) / 2
elif ob1.hz_obs < ob2.hz_obs:
ob2_shift = -(DMSAngle(360) - ob2.hz_obs)
meaned_hz = (ob1.hz_obs + ob2_shift) / 2
if meaned_hz < DMSAngle(0):
meaned_hz = meaned_hz + DMSAngle(360)
elif ob2.hz_obs < ob1.hz_obs:
ob1_shift = -(DMSAngle(360) - ob1.hz_obs)
meaned_hz = (ob1_shift + ob2.hz_obs) / 2
if meaned_hz < DMSAngle(0):
meaned_hz = meaned_hz + DMSAngle(360)
meaned_va = (ob1.va_obs + ob2.va_obs) / 2
meaned_sd = round(((ob1.sd_obs + ob2.sd_obs) / 2), 4)
return Observation(ob1.from_id,
ob1.to_id,
ob1.inst_height,
ob1.target_height,
ob1.face,
ob1.rounds + ob2.rounds,
meaned_hz,
ob1.hz_stdev,
meaned_va,
ob1.va_stdev,
meaned_sd,
ob1.sd_stdev)
def parse_angle(obs_string):
dms = float(obs_string)
degmin, second = divmod(abs(dms) * 1000, 10)
degree, minute = divmod(degmin, 100)
return DMSAngle(degree, minute, second * 10)
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))
import unittest
from geodepy.convert import dec2hp, hp2dec, DMSAngle, DDMAngle, dec2dms, dec2ddm, hp2dms, hp2ddm, dd2dms
dec_ex = 123.74875
dec_ex2 = 12.575
hp_ex = 123.44555
hp_ex2 = 12.3430
dms_ex = DMSAngle(123, 44, 55.5)
dms_ex2 = DMSAngle(12, 34, 30)
dms_ex3 = DMSAngle(-12, -34, -30)
ddm_ex = DDMAngle(123, 44.925)
ddm_ex2 = DDMAngle(12, 34.5)
ddm_ex3 = DDMAngle(-12, -34.5)
class TestConvert(unittest.TestCase):
def test_dec2hp(self):
self.assertAlmostEqual(hp_ex, dec2hp(dec_ex), 13)
self.assertAlmostEqual(-hp_ex, dec2hp(-dec_ex), 13)
def test_hp2dec(self):
self.assertAlmostEqual(dec_ex, hp2dec(hp_ex), 13)
self.assertAlmostEqual(-dec_ex, hp2dec(-hp_ex), 13)
self.assertAlmostEqual(
hp2dec(hp_ex) + hp2dec(hp_ex2), dec_ex + dec_ex2, 13)
def test_DMSAngle(self):
# Test DMSAngle Methods
self.assertEqual(dec_ex, dms_ex.dec())
def test_DMSAngle(self):
# Test DMSAngle Methods
self.assertEqual(dec_ex, dms_ex.dec())
self.assertEqual(hp_ex, dms_ex.hp())
self.assertEqual(hp_ex3, dms_ex3.hp())
self.assertEqual(ddm_ex, dms_ex.ddm())
# Test DMSAngle Sign Conventions
self.assertEqual(
-dec_ex,
DMSAngle(-dms_ex.degree, dms_ex.minute, dms_ex.second).dec())
self.assertEqual(
dec_ex,
DMSAngle(dms_ex.degree, -dms_ex.minute, -dms_ex.second).dec())
self.assertAlmostEqual(
-dec_ex4,
DMSAngle(0, -dms_ex4.minute, dms_ex4.second).dec(), 9)
self.assertAlmostEqual(
dec_ex4,
DMSAngle(0, dms_ex4.minute, dms_ex4.second).dec(), 9)
self.assertEqual(-dec_ex5, DMSAngle(0, 0, -dms_ex5.second).dec())
self.assertEqual(dec_ex5, DMSAngle(0, 0, dms_ex5.second).dec())
self.assertEqual(dms_ex.sign, 1)
self.assertEqual(-dms_ex.sign, -1)
self.assertEqual(dms_ex4.sign, 1)
self.assertEqual(-dms_ex4.sign, -1)
self.assertEqual(dms_ex5.sign, 1)
self.assertEqual(-dms_ex5.sign, -1)
self.assertEqual(DMSAngle(-1, 2, 3).sign, -1)
self.assertEqual(DMSAngle(1, -2, 3).sign, 1)
self.assertEqual(DMSAngle(1, 2, -3).sign, 1)
self.assertEqual(DMSAngle(0, -1, 2).sign, -1)
self.assertEqual(DMSAngle(0, 0, -3).sign, -1)
self.assertEqual(DMSAngle(-0, 1, 2).sign, 1)
self.assertEqual(DMSAngle(-0.0, 1, 2).sign, -1)
# Test DMSAngle Overloads
self.assertEqual(dec_ex + dec_ex2, (dms_ex + dms_ex2).dec())
self.assertEqual(dec_ex - dec_ex2, (dms_ex - dms_ex2).dec())
self.assertEqual(dec_ex * 5, (dms_ex * 5).dec())
self.assertEqual(5 * dec_ex, (5 * dms_ex).dec())
self.assertEqual(dec_ex / 3, (dms_ex / 3).dec())
self.assertEqual(abs(-dms_ex), dms_ex)
self.assertEqual(-dms_ex2, dms_ex3)
self.assertEqual(dms_ex2, abs(dms_ex3))
self.assertEqual(dms_ex, ddm_ex)
self.assertTrue(dms_ex == dms_ex)
self.assertFalse(dms_ex == dms_ex2)
self.assertTrue(dms_ex != dms_ex2)
self.assertFalse(dms_ex != dms_ex)
self.assertTrue(dms_ex > dms_ex2)
self.assertFalse(dms_ex2 > dms_ex)
self.assertTrue(dms_ex2 < dms_ex)
self.assertFalse(dms_ex < dms_ex2)
with self.assertRaises(TypeError):
dms_ex * 'a'
with self.assertRaises(TypeError):
'a' * dms_ex
with self.assertRaises(TypeError):
dms_ex / 'a'
def fbk2class(fbk_list):
def parse_angle(obs_string):
dms = float(obs_string)
degmin, second = divmod(abs(dms) * 1000, 10)
degree, minute = divmod(degmin, 100)
return DMSAngle(degree, minute, second * 10)
fbk_project = []
for setup_list in fbk_list:
obs_list = []
if setup_list[0][0] == 'STN' and len(setup_list[0]) <= 3:
# This is the station information part
from_id = setup_list[0][1]
inst_height = float(setup_list[0][2])
coord = Coordinate(from_id, 'utm', 'gda94', 'gda94', '2018.1', 0,
0, 0)
setup = InstSetup(from_id, coord)
elif setup_list[0][0] == 'STN' and len(setup_list[0]) > 3:
from_id = setup_list[0][1]
inst_height = float(setup_list[0][2])
east = float(setup_list[0][3])
north = float(setup_list[0][4])
elev = float(setup_list[0][5])
coord = Coordinate(from_id, 'utm', 'gda94', 'gda94', '2018.1',
east, north, elev)
setup = InstSetup(from_id, coord)
for record in setup_list:
if record[0] == 'F1' or record[0] == 'F2':
"""
This is the obs information part
from_id, to_id, inst_height, target_height
face
hz_obs
va_obs
sd_obs
hz_dist
vert_dist
"""
# Read Face
if int(float(record[5])) in range(0, 180):
face = 'FL'
elif int(float(record[5])) in range(180, 360):
face = 'FR'
else:
ValueError('Invalid Vertical Angle in ' + record)
to_id = record[2] # Read To ID
rounds = 0.5
hz_obs = parse_angle(record[3]) # 3 is Hz Ob (HP)
hz_stdev = DMSAngle(0)
sd_obs = float(record[4])
sd_stdev = 0.0
va_obs = parse_angle(record[5]) # 5 is Vert Ob (HP)
va_stdev = DMSAngle(0)
target_height = float(record[7])
obs = Observation(from_id, to_id, inst_height, target_height,
face, rounds, hz_obs, hz_stdev, va_obs,
va_stdev, sd_obs, sd_stdev)
obs_list.append(obs)
# else:
# raise ValueError('Unexpected format found')
for i in obs_list:
setup.addobs(i)
fbk_project.append(setup)
return fbk_project
