Georeference Area Targets to obtain the geolocation of their origin and rotationangle with respect to the WGS 84 geographic coordinate system. We describe three different options to achieve this below.
Georeferencing your Area Targets with one of the below described methods allows you to use the geolocation of the device as External Prior for Area Targets based experiences, especially in large spaces. Once you have determined the latitude and longitude of the Area Target’s origin, and its orientation’s CCW (counterclockwise) rotation angle with respect to the North direction, you can follow the Use Device Geolocation as Prior guide to build your app.
Method 1: Geolocate the Original Scan of the Area Target
Some scanning solutions provide facilities for georegistration and alignment of the scan. If this data is available, the Area Target generation will respect the origin of the input scanned data.
 Register the origin of the scan with the scanning provider’s software.
 Preserve the origin’s geolocation as information for your app if you need to align assets to this coordinate system or if you have other offsets to deal with. Have the latitude and longitude of the scan data’s origin, and its orientation as a CCW rotation angle with respect to the North direction ready for development.
NOTE: Area Targets are defined with an upwards pointing Yaxis, so it may be necessary to perform an additional rotation to make everything Yup if the scanned input data uses a different convention.
Vendor specific information:
 When using NavVis scans, your scan is created in IVION and can be georeferenced during the data import. This reference will be retained during the processing of the raw scan data into the E57 artifact. See further information in the NavVis documentation.
 Leica REGISTER 360 can align scans during import using the builtin GeoImage alignment support, or by using a list of georeferenced control points, that you can apply to your registered bundle. Using the RTC360 you can also leverage the measurement of the onboard GPS sensor for autoalignment. Consult the Leica Cyclone REGISTER 360 quick start guide or the builtin documentation of the tool.
With the retrieved latitude and longitude, and rotation you can start to Use Device Geolocation as Prior.
Method 2: Manual Alignment of Authoring Model with Satellite Imagery
Estimate the alignment manually in the Unity Editor using a topdown view of the Area Target authoring model with a paired satellite image. The accuracy of this approach will depend on how easy it is to visually align the scanned location with the information visible on a satellite image. In addition to the Unity Editor, you will need an image editor for the alignment.
Follow the below steps:
 Look up your scan location using any mapping service that shows enough detail to align your Area Target which also allows you to read out exact coordinates. In this example we’ll use Google Maps to look up the “Area Target Sample” target – which shows the Customer Experience Center at our Headquarters in Seaport, Boston, MA.
NOTE: we are using the Map view, and not the Globe view mode. This might yield some errors on tall buildings in some places but some of the below steps don’t work with Globe view.
 Markup a known distance in the map with the ruler tool to aid scaling later below in Unity.
 Capture the satellite image with the scale marked. To aid alignment in Unity, crop the image in an image editing tool to be square.
 Import your Area Target into the Unity Editor as described in the Area Targets in Unity
 Verify the origin of your AT in Unity to be at (0,0,0). Make sure to select the Pivot mode, to see the true origin location of the local coordinate system (and not the center of the GameObject).
NOTE: The origin of the scan can lie outside of the actual area covered by the Area Target due to original scanprocessing or Space3DT cropping in ATG as in this example.  Switch to Unity’s Scene View to orthographic mode in a topdown view by clicking the cube in the middle and the green cone.
Selecting the Area Target will display its origin with an axis gizmo.
 Import the captured image into Unity Editor as an asset, create a new plane GameObject, and apply the image as its texture. Per default the plane is square. Cropping the image in the previous step helps keeping the aspectratio correct, otherwise you need to correct for that at this point. Switch the transforms for this GameObject from Global to Local.
 Scale the plane uniformly, so that the ruler’s scale coincides with Unity’s grid – in below example 20m is around the second gridline from origin. If you have done it correctly, the Area Target and the satellite image should be the same scale and sizewise fit each other. Remember, everything is in meters in the Unity Editor. The resulting scale factor – here 9.332943 – is arbitrary as it depends on the zoom factor in maps.
 Translate and rotate the plane to georeference the Area Target. The local coordinate system of the plane GameObject will move and rotate. Originally the blue Z axis of the plane was aligned with the North direction. To align with the Area Target, we have to rotate the satellite image to provide the CCW rotation with respect to the North direction angle = 95 degrees.
 Find the Area Target’s origin location in the satellite image by selecting the Area Target and zooming in around (0,0) in the Scene View. Since the Area Target is still located at the origin (check to use Pivot!) and we moved the map underneath, the point on the map under the Area Target’s (0,0) origin will be our reference point – the geolocation of the Area Target’s origin.
 Lookup the origin’ geolocation on a mapping service (on Google Maps rightclick the origin’s location). By clicking on the coordinates in the context menu, pick up the
(latitude,longitude) = (42.35072572772756, 71.04457501396098) .
With the retrieved latitude and longitude, and CCW rotation angle to the North direction you can start to Use Device Geolocation as Prior.
Method 3: Align by Using Measured Area Target and GPSdevice Poses
This method may be convenient if the other described methods for georeferencing are not possible, or if you wish to verify the results of one of the other methods. It uses a Python script and an input file that contains measurements to align an Area Target pose with the geolocation of the Area Target’s origin. The resulting accuracy depends on the quality of the measurement data provided.
Approach 1: Collecting sample location data offline on your Desktop
The best results may be achieved by identifying well defined sample locations in the target (building corners, roofwindows, A/Cunity, or road markings) whose geolocations can be relatively accurately lookedup from satellite imagery and identified with the Area Target’s Authoring Model.
Area Target Coordinate System 
Geolocation in WGS 84


X 
Y 
Z 
Latitude 
Longitude 
Altitude 

Sample location 1 
10.0 
1.0 
0.0 
65.814396 
125.076176 
2.94844144 
Sample location 2 
10.0 
1.0 
0.0 
65.814554 
125.076076 
2.08687038 
… 
… 
… 
… 
… 
… 
… 
To measure locations within the Area Target in the Unity Editor, create an empty GameObject, and name it e.g., as “Sample location 1”. Select the GameObject to reveal its origin with pivot selected. You can now move and rotate the gizmo to align with your sample locations in your scene.
Find the same locations in the satellite image and match their geolocation as showed in the above example table.
This approach works well in situations, where objects or pieces of the environment in the captured location can be identified and they are visible from above – such as they are visible in a satellite image.
Approach 2: Collecting sample location data onsite with a Mobile Device and a custom app
Alternatively, the data for above table may also be collected by measuring and logging pairs of data with a simple, custombuilt app. This app should read Vuforia Area Target Poses and GPSpositions at various samplelocations within the environment.
The GPSLocationProvider.cs script in the Use Device Geolocation as Prior page shows how to read out the GPS position.
To capture the device’s location within the Area Target coordinate system at runtime you must transpose the device location with the following snippet.
class DevicePoseConverter : MonoBehaviour
{
AreaTargetBehaviour AreaTarget;
DevicePoseBehaviour DevicePose;
void DPPoseToATLocalSpace()
{
DevicePose.transform.SetParent(AreaTarget.transform);
var devicePositionInAreaTarget = DevicePose.transform.localPosition;
DevicePose.transform.SetParent(null);
}
}
This method may give a less accurate results since live GPS measurements in or around buildings are likely to have a few meters of error. In this case, the best action is to take several widely spaced measurements around the target in locations where GPS accuracy is as good as possible.
Prepare the alignment data file
Getting enough and goodquality measurements depend on the GPS signal strength and accuracy. We recommend getting at least a few sample locations with more than a meter between them when the data is considered accurate, and up to a dozen sample locations if the GPS measurements are considered inaccurate.
The alignment Python script in the next section expects an input file with pairs of device positions in the Area Target and geolocations. An example alignmentinput.txt file shows the expected format:
# device position in Area Target (x y z), device position in GPS (lat lon alt)
10.0 1.0 0.0 65.81439611 125.07617591 0.94844144
10.0 1.0 0.0 65.8145536 125.076076 0.0868703835
0.0 1.0 10.0 65.81440561 125.07592207 2.98062477
Align Area Target poses with GPS coordinates
Finally, below you can find the Area Target GeoLocation Estimator Python script that aligns Area Target poses and the GPS coordinates as collected and provided in a formatted input file.
NOTE: This script only works for 2D alignment of the Area Target.
NOTE: To run this script, your Python installation must have the dependencies; argparse
, random
, numpy
, and skimage
.
Running below script with the input file will generate the georeferencing information for the Area Target. Use the Python command python script.py i path_to_input.txt
to run the script.
With the retrieved latitude and longitude, and rotation angle CCW to the North direction, you can start to Use Device Geolocation as Prior.
#===============================================================================
# Copyright (c) 2022 PTC Inc. All Rights Reserved.
# Vuforia is a trademark of PTC Inc., registered in the United States and other
# countries.
#===============================================================================
"""Area Target GeoLocation Estimator
This script estimates the geolocation and orientation of an Area Target from
pairs of Area Target and GPS device positions.
It expects a .txt input file with rows that contain pairs of device positions
in the format (x y z lat lon alt), where (x,y,z) is the device position in the
Area Target coordinate system and (lat,lon,alt) is the corresponding GPS
position with latitude and longitude in degrees and altitude in meters.
The GPS coordinates are converted to a Cartesian EastNorthUp (ENU) coordinate
system for alignment with the Area Target coordinate system.
The estimated (lat,lon,alt) coordinates of the Area Target origin are printed
to the console, along with the counterclockwise angle in degrees from the North
direction to the Area Target Zaxis.
Note that the conversion from GPS to ENU and viceversa uses an approximate
method. For points distributed within 100m of each other, it should provide
good enough results to get started. For larger Area Targets, consider
substituting with a more accurate method from a Python geodesy library.
"""
import argparse
import random
import numpy as np
from skimage import transform
def get_earth_radius(latitude):
"""Computes the local earth radius (meters) at the given latitude (degrees)
The radius is approximated by interpolating between the radius at the equator
and the radius at the North Pole.
"""
EARTH_RADIUS_METERS_EQUATOR = 6378137.
EARTH_RADIUS_METERS_NORTH_POLE = 6356752.314245
theta = np.deg2rad(latitude)
rst = EARTH_RADIUS_METERS_EQUATOR * np.sin(theta)
rct = EARTH_RADIUS_METERS_NORTH_POLE * np.cos(theta)
radius = EARTH_RADIUS_METERS_EQUATOR * EARTH_RADIUS_METERS_NORTH_POLE / np.sqrt(
rst * rst + rct * rct)
return radius
def gps_to_enu(gps_position, gps_origin):
"""Converts from latitude, longitude, altitude to East, North, Up (ENU) coordinates
Note that this is an approximate method. For points distributed within 100m of each
other, it should provide good enough results to get started. For larger Area Targets,
consider substituting with a more accurate method from a Python geodesy library.
Parameters

gps_position : numpy array
Array containing (lat, lon, alt) of the position to convert, where latitude and
longitude are in degrees and altitude is in meters
gps_origin : numpy array
Array containing (lat, lon, alt) of the local origin of the ENU coordinate system,
where latitude and longitude are in degrees and altitude is in meters. Note that
origin should be defined as close as possible to the other GPS positions.
Returns

numpy array
Array containing (east, north, up) coordinates in meters relative to the
provided origin
"""
local_earth_radius = get_earth_radius(gps_origin[0])
latitude_degrees_to_meters = local_earth_radius * np.pi / 180.
longitude_radius = local_earth_radius * np.cos(np.deg2rad(gps_origin[0]))
longitude_degrees_to_meters = longitude_radius * np.pi / 180.
relative_position = gps_position  gps_origin
east = relative_position[1] * longitude_degrees_to_meters
north = relative_position[0] * latitude_degrees_to_meters
up = relative_position[2]
return np.array([east, north, up])
def enu_to_area_target(enu_position, gps_orientation_angle):
"""Converts from East, North, Up (ENU) coordinates to Area Target coordinates
Parameters

enu_position : numpy array
Array containing (east, north, up) position in meters to convert
gps_orientation_angle : float
Counterclockwise angle in degrees from the North direction to the Area
Target Zaxis
Returns

numpy array
Array containing (x, y, z) Area Target coordinates in meters, where Yaxis
points up
"""
gps_orientation_angle_rad = np.deg2rad(gps_orientation_angle)
x = enu_position[0] * np.cos(gps_orientation_angle_rad)  enu_position[
1] * np.sin(gps_orientation_angle_rad)
y = enu_position[2]
z = enu_position[0] * np.sin(gps_orientation_angle_rad) + enu_position[
1] * np.cos(gps_orientation_angle_rad)
return np.array([x, y, z])
def gps_to_area_target(gps_position, gps_origin, gps_orientation_angle):
"""Converts from latitude, longitude, altitude to Area Target coordinates
Parameters

gps_position : numpy array
Array containing (lat, lon, alt) of the position to convert, where latitude and
longitude are in degrees and altitude is in meters
gps_origin : numpy array
Array containing (lat, lon, alt) of the local origin of the ENU coordinate system,
where latitude and longitude are in degrees and altitude is in meters. Note that
origin should be defined as close as possible to the other GPS positions.
gps_orientation_angle : float
Counterclockwise angle in degrees from the North direction to the Area Target
Zaxis
Returns

numpy array
Array containing (x, y, z) Area Target coordinates in meters, where Yaxis
points up
"""
enu_position = gps_to_enu(gps_position, gps_origin)
return enu_to_area_target(enu_position, gps_orientation_angle)
def area_target_to_enu(area_target_position, gps_orientation_angle):
"""Converts from Area Target coordinates to East, North, Up (ENU) coordinates
Parameters

area_target_position : numpy array
Array containing (x, y, z) position in meters to convert, where Yaxis
points up
gps_orientation_angle : float
Counterclockwise angle in degrees from the North direction to the Area
Target Zaxis
Returns

numpy array
Array containing (east, north, up) coordinates in meters
"""
gps_orientation_angle_rad = np.deg2rad(gps_orientation_angle)
e = area_target_position[0] * np.cos(
gps_orientation_angle_rad) + area_target_position[2] * np.sin(
gps_orientation_angle_rad)
n = area_target_position[2] * np.cos(
gps_orientation_angle_rad)  area_target_position[0] * np.sin(
gps_orientation_angle_rad)
u = area_target_position[1]
return np.array([e, n, u])
def enu_to_gps(enu_position, gps_origin):
"""Converts from East, North, Up (ENU) coordinates to latitude, longitude, altitude
Note that this is an approximate method. For points distributed within 100m of each
other, it should provide good enough results to get started. For larger Area Targets,
consider substituting with a more accurate method from a Python geodesy library.
Parameters

enu_position : numpy array
Array containing (lat, lon, alt) of the position to convert, where latitude and
longitude are in degrees and altitude is in meters
gps_origin : numpy array
Array containing (lat, lon, alt) of the local origin of the ENU coordinate system,
where latitude and longitude are in degrees and altitude is in meters. Note that
origin should be defined as close as possible to the other GPS positions.
Returns

numpy array
Array containing (lat, lon, alt), where latitude and longitude are in degrees
and altitude is in meters
"""
local_earth_radius = get_earth_radius(gps_origin[0])
latitude_degrees_to_meters = local_earth_radius * np.pi / 180.
longitude_radius = local_earth_radius * np.cos(np.deg2rad(gps_origin[0]))
longitude_degrees_to_meters = longitude_radius * np.pi / 180.
relative_longitude_degrees = enu_position[0] / longitude_degrees_to_meters
relative_latitude_degrees = enu_position[1] / latitude_degrees_to_meters
relative_altitude_meters = enu_position[2]
latitude = relative_latitude_degrees + gps_origin[0]
longitude = relative_longitude_degrees + gps_origin[1]
altitude = relative_altitude_meters + gps_origin[2]
return np.array([latitude, longitude, altitude])
def area_target_to_gps(area_target_position, gps_origin,
gps_orientation_angle):
"""Converts from Area Target coordinates to latitude, longitude, altitude
Parameters

area_target_position : numpy array
Array containing (x, y, z) Area target position in meters to convert, where Yaxis
points up
gps_origin : numpy array
Array containing (lat, lon, alt) of the local origin of the ENU coordinate system,
where latitude and longitude are in degrees and altitude is in meters. Note that
origin should be defined as close as possible to the other GPS positions.
gps_orientation_angle : float
Counterclockwise angle in degrees from the North direction to the Area Target
Zaxis
Returns

numpy array
Array containing (lat, lon, alt), where latitude and longitude are in degrees
and altitude is in meters
"""
enu_position = area_target_to_enu(area_target_position,
gps_orientation_angle)
return enu_to_gps(enu_position, gps_origin)
def estimate_offset(area_target_positions, gps_positions):
"""Estimates the geolocation and orientation of an Area Target
Parameters

area_target_positions : numpy array
Array of (x, y, z) Area target positions in meters, where Yaxis points up
gps_positions : numpy array
Array of (lat, lon, alt) GPS coordinates corresponding to the Area Target
positions, where latitude and longitude are in degrees and altitude is in
meters.
Returns

numpy array
Array containing the estimated (lat, lon, alt) of the Area Target orgin, where
latitude and longitude are in degrees and altitude is in meters. Note that only
latitude and longitude are actually estimated, so altitude always returns as zero.
float
Estimated counterclockwise angle in degrees from the North direction to the Area
Target Zaxis
"""
# use average GPS position as local coordinate origin for conversion to ENU
gps_origin = np.mean(gps_positions, axis=0)
converted_gps_positions = [
gps_to_enu(pos, gps_origin) for pos in gps_positions
]
enu_positions = np.array(converted_gps_positions)
# estimate 2D transform from Area Target XZ to EastNorth
en_positions = enu_positions[:, 0:2]
area_target_xz_positions = np.take(area_target_positions, [0, 2], axis=1)
tform_xz_to_en = transform.estimate_transform('euclidean',
area_target_xz_positions,
en_positions)
area_target_xz_origin = np.array([0., 0.])
area_target_en_origin = transform.matrix_transform(area_target_xz_origin,
tform_xz_to_en.params)
area_target_enu_origin = np.array(
[area_target_en_origin[0][0], area_target_en_origin[0][1], 0.])
area_target_gps_origin = enu_to_gps(area_target_enu_origin, gps_origin)
# orientation angle should rotate from North to Area Target zaxis
orientation_angle_rad = np.arctan2(tform_xz_to_en.params[0][1],
tform_xz_to_en.params[0][0])
orientation_angle = np.rad2deg(orientation_angle_rad)
return np.array([area_target_gps_origin[0], area_target_gps_origin[1],
0.]), orientation_angle
def generate_random_gps_origin_and_orientation_angle():
"""Generates a random GPS origin and orientation angle
Returns

numpy array
Array containing the estimated (lat, lon, alt) of the Area Target orgin, where
latitude and longitude are in degrees and altitude is in meters. Note that only
latitude and longitude are actually estimated, so altitude always returns as zero.
float
Estimated counterclockwise angle in degrees from the North direction to the Area
Target Zaxis
"""
randR = random.uniform
return np.array([randR(90., 90.),
randR(180., 180.), 0.]), randR(180., 180.)
def generate_random_area_target_position():
"""Generates a random Area Target position
Returns

numpy array
Array containing (x, y, z) Area Target coordinates in meters, where Yaxis
points up
"""
randR = random.uniform
return np.array([randR(20., 20.), randR(0.5, 2.), randR(20., 20.)])
def generate_noisy_gps_position(area_target_position, gps_origin,
gps_orientation_angle, gps_noise, alt_noise):
"""Generates a GPS position with artificial noise from an Area Target position
Parameters

area_target_position : numpy array
Array containing (x, y, z) Area target position in meters to convert, where Yaxis
points up
gps_origin : numpy array
Array containing (lat, lon, alt) of the local origin of the ENU coordinate system,
where latitude and longitude are in degrees and altitude is in meters. Note that
origin should be defined as close as possible to the other GPS positions.
gps_orientation_angle : float
Counterclockwise angle in degrees from the North direction to the Area Target Zaxis
gps_noise : float
Standard deviation of noise in meters to add to latitude and longitude coordinates
alt_noise : float
Standard deviation of noise in meters to add to altitude coordinate
Returns

numpy array
Array containing (lat, lon, alt), where latitude and longitude are in degrees
and altitude is in meters
"""
randR = random.gauss
noisy_area_target_position = np.array([
randR(area_target_position[0], gps_noise),
randR(area_target_position[1], alt_noise),
randR(area_target_position[2], gps_noise)
])
noisy_enu_position = area_target_to_enu(noisy_area_target_position,
gps_orientation_angle)
noisy_gps_position = enu_to_gps(noisy_enu_position, gps_origin)
return noisy_gps_position
def run_from_artificial_data(area_target_positions, gps_origin,
gps_orientation_angle, gps_noise, alt_noise):
"""Tests the estimation of Area Target geolocation and orientation from artifical data
The input Area Target positions are used to compute artificial noisy GPS measurements
based on the provided GPS origin and orientation angle. The geolocation and orientation
of the Area Target is then estimated from the Area Target positions and noisy GPS
measurements. The result is compared against the original GPS origin and orientation
angle and the error is printed out.
Parameters

area_target_positions : numpy array
Array of (x, y, z) Area target positions in meters, where Yaxis points up
gps_origin : numpy array
Array containing (lat, lon, alt) of the local origin of the ENU coordinate system,
where latitude and longitude are in degrees and altitude is in meters. Note that
origin should be defined as close as possible to the other GPS positions.
gps_orientation_angle : float
Counterclockwise angle in degrees from the North direction to the Area Target Zaxis
gps_noise : float
Standard deviation of noise in meters to add to latitude and longitude coordinates
alt_noise : float
Standard deviation of noise in meters to add to altitude coordinate
"""
gps_positions = np.array([
generate_noisy_gps_position(pos, gps_origin, gps_orientation_angle,
gps_noise, alt_noise)
for pos in area_target_positions
])
estimated_gps_origin, estimated_gps_orientation_angle = estimate_offset(
area_target_positions, gps_positions)
estimated_enu_origin = gps_to_enu(estimated_gps_origin, gps_origin)
print("Estimated GPS origin error (degrees):")
print(estimated_gps_origin[0:2]  gps_origin[0:2])
print("Estimated ENU origin error (meters):")
print(estimated_enu_origin)
print("Estimated orientation angle error (degrees):")
print(estimated_gps_orientation_angle  gps_orientation_angle)
def test_random_points(num_positions, gps_origin, gps_orientation_angle,
gps_noise, alt_noise):
"""Tests the estimation of Area Target geolocation and orientation from a set of random points"""
print("")
print("Testing offset calculation from random points")
area_target_positions = np.array([
generate_random_area_target_position() for __ in range(num_positions)
])
run_from_artificial_data(area_target_positions, gps_origin,
gps_orientation_angle, gps_noise, alt_noise)
def test_T_shape(gps_origin, gps_orientation_angle, gps_noise, alt_noise):
"""Tests the estimation of Area Target geolocation and orientation from a set of 3 points"""
print("")
print("Testing offset calculation from 3 positions in Tshape")
area_target_positions = np.array([[10., 1., 0.], [10., 1., 0.],
[0., 1., 10.]])
run_from_artificial_data(area_target_positions, gps_origin,
gps_orientation_angle, gps_noise, alt_noise)
def run_tests(seed):
"""Runs a set tests using artificial data"""
random.seed(seed)
gps_noise = 5.
alt_noise = 1.
random_gps_origin, random_gps_orientation_angle = generate_random_gps_origin_and_orientation_angle(
)
print("")
print("GPS origin latitude, longitude (degrees), altitude (meters):")
print(random_gps_origin)
print("GPS orientation angle (degrees):")
print(random_gps_orientation_angle)
print("GPS noise magnitude (meters):")
print(gps_noise)
print("Altitude noise magnitude (meters):")
print(alt_noise)
test_random_points(5, random_gps_origin, random_gps_orientation_angle,
gps_noise, alt_noise)
test_T_shape(random_gps_origin, random_gps_orientation_angle, gps_noise,
alt_noise)
def run_from_file(input_file_path):
"""Estimates Area Target geolocation and orientation from data loaded from a file
Expects a .txt input file with rows that contain pairs of device positions
in the format (x y z lat lon alt), where (x,y,z) is the device position in the
Area Target coordinate system and (lat,lon,alt) is the corresponding GPS
position with latitude and longitude in degrees and altitude in meters.
The estimated (lat,lon,alt) coordinates of the Area Target origin are printed
to the console, along with the counterclockwise angle in degrees from the North
direction to the Area Target Zaxis.
Parameters

input_file_path : str
Path of file containing input data in specified format
"""
f = open(input_file_path, 'r')
area_target_positions = np.loadtxt(f, usecols=(0, 1, 2))
f.close()
f = open(input_file_path, 'r')
gps_positions = np.loadtxt(f, usecols=(3, 4, 5))
f.close()
estimated_gps_origin, estimated_gps_orientation_angle = estimate_offset(
area_target_positions, gps_positions)
print(
"Estimated GPS location of Area Target origin (latitude, longitude (degrees), altitude (meters)):"
)
print(estimated_gps_origin)
print(
"Estimated counterclockwise angle from North to Area Target zaxis (degrees):"
)
print(estimated_gps_orientation_angle)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"i",
"input",
help=
"path to input file containing pairs of device coordinates in the area target and GPS coordinate systems"
)
parser.add_argument(
"t",
"test",
action='store_true',
help="use randomly generated input data instead of input file")
parser.add_argument(
"s",
"seed",
default=1,
type=int,
help=
"random seed to use when running test with randomly generated input data"
)
args = parser.parse_args()
if args.input:
run_from_file(args.input)
elif args.test:
run_tests(args.seed)
else:
parser.print_help()
if __name__ == '__main__':
main()