/// <summary>
/// Calculate the two-dimensional path from
/// Lincoln Memorial in Washington, D.C --> 38.8892N, 77.04978W
/// to
/// Eiffel Tower in Paris --> 48.85889N, 2.29583E
/// using
/// WGS84 reference ellipsoid
/// </summary>
static void TwoDimensionalInverseCalculation()
{
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
// set Lincoln Memorial coordinates
GlobalCoordinates lincolnMemorial;
lincolnMemorial = new GlobalCoordinates(
new Angle(38.88922), new Angle(-77.04978)
);
// set Eiffel Tower coordinates
GlobalCoordinates eiffelTower;
eiffelTower = new GlobalCoordinates(
new Angle(48.85889), new Angle(2.29583)
);
// calculate the geodetic curve
GeodeticCurve geoCurve = geoCalc.CalculateGeodeticCurve(reference, lincolnMemorial, eiffelTower);
double ellipseKilometers = geoCurve.EllipsoidalDistance / 1000.0;
double ellipseMiles = ellipseKilometers * 0.621371192;
Console.WriteLine("2-D path from Lincoln Memorial to Eiffel Tower using WGS84");
Console.WriteLine(" Ellipsoidal Distance: {0:0.00} kilometers ({1:0.00} miles)", ellipseKilometers, ellipseMiles);
Console.WriteLine(" Azimuth: {0:0.00} degrees", geoCurve.Azimuth.Degrees);
Console.WriteLine(" Reverse Azimuth: {0:0.00} degrees", geoCurve.ReverseAzimuth.Degrees);
}
/// <summary>
/// Calculate the destination if we start at:
/// Lincoln Memorial in Washington, D.C --> 38.8892N, 77.04978W
/// and travel at
/// 51.7679 degrees for 6179.016136 kilometers
///
/// WGS84 reference ellipsoid
/// </summary>
static void TwoDimensionalDirectCalculation()
{
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
// set Lincoln Memorial coordinates
GlobalCoordinates lincolnMemorial;
lincolnMemorial = new GlobalCoordinates(
new Angle(38.88922), new Angle(-77.04978)
);
// set the direction and distance
Angle startBearing = new Angle(51.7679);
double distance = 6179016.13586;
// find the destination
Angle endBearing;
GlobalCoordinates dest = geoCalc.CalculateEndingGlobalCoordinates(reference, lincolnMemorial, startBearing, distance, out endBearing);
Console.WriteLine("Travel from Lincoln Memorial at 51.767921 deg for 6179.016 km");
Console.Write(" Destination: {0:0.0000}{1}", dest.Latitude.Degrees, (dest.Latitude > 0) ? "N" : "S");
Console.WriteLine(", {0:0.0000}{1}", dest.Longitude.Degrees, (dest.Longitude > 0) ? "E" : "W");
Console.WriteLine(" End Bearing: {0:0.00} degrees", endBearing.Degrees);
}
public void TestAntiPodal2()
{
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
// set position 1
GlobalCoordinates p1;
p1 = new GlobalCoordinates(11, 80);
// set position 2
GlobalCoordinates p2;
p2 = new GlobalCoordinates(-10, -100);
// calculate the geodetic measurement
GeodeticCurve geoCurve;
geoCurve = geoCalc.CalculateGeodeticCurve(reference, p1, p2);
Assert.AreEqual(19893320.272061437, geoCurve.EllipsoidalDistance, 0.001);
Assert.AreEqual(360.0, geoCurve.Azimuth.Degrees, 0.0000001);
Assert.AreEqual(0.0, geoCurve.ReverseAzimuth.Degrees, 0.0000001);
}
public void TestPoleCrossing()
{
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
// set Lincoln Memorial coordinates
GlobalCoordinates lincolnMemorial = new GlobalCoordinates(Angle.FromDegrees(38.88922), Angle.FromDegrees(-77.04978));
// set a bearing of 1.0deg (almost straight up) and a distance
Angle startBearing = Angle.FromDegrees(1);
double distance = 6179016.13586;
// set the expected destination
GlobalCoordinates expected = new GlobalCoordinates(Angle.FromDegrees(85.60006433), Angle.FromDegrees(92.17243943));
// calculate the ending global coordinates
Angle endBearing;
GlobalCoordinates dest = geoCalc.CalculateEndingGlobalCoordinates(reference, lincolnMemorial, startBearing, distance, out endBearing);
Assert.AreEqual(expected.Latitude.Degrees, dest.Latitude.Degrees, StandardTolerance);
Assert.AreEqual(expected.Longitude.Degrees, dest.Longitude.Degrees, StandardTolerance);
}
public void TestCalculateGeodeticCurve()
{
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
// set Lincoln Memorial coordinates
GlobalCoordinates lincolnMemorial;
lincolnMemorial = new GlobalCoordinates(38.88922, -77.04978);
// set Eiffel Tower coordinates
GlobalCoordinates eiffelTower;
eiffelTower = new GlobalCoordinates(48.85889, 2.29583);
// calculate the geodetic curve
GeodeticCurve geoCurve = geoCalc.CalculateGeodeticCurve(reference, lincolnMemorial, eiffelTower);
Assert.AreEqual(6179016.136, geoCurve.EllipsoidalDistance, 0.001);
Assert.AreEqual(51.76792142, geoCurve.Azimuth.Degrees, 0.0000001);
Assert.AreEqual(291.75529334, geoCurve.ReverseAzimuth.Degrees, 0.0000001);
}
public double Distance(String lat1, String lon1, String lat2, String lon2)
{
//The geodesy library calculates distance between two geo coordinates based on
//Vincenty's Formula. This library class contains parameters to calculate the distance.
//The Ellipsoid value is based on the geographic location. Australia follows GRS80
//Ellipsoid based on its demography.
//The class was created by Gavaghan http://www.gavaghan.org/blog/free-source-code/geodesy-library-vincentys-formula/
Ellipsoid reference = Ellipsoid.GRS80;
//Create new object for geodetic calculator.
GeodeticCalculator geoCalc = new GeodeticCalculator(reference);
//Set the coordinates for point A
GlobalCoordinates pointA;
pointA = new GlobalCoordinates(
new Angle(Convert.ToDouble(lat1)), new Angle(Convert.ToDouble(lon1))
);
//Set the coordinates for point B
GlobalCoordinates pointB;
pointB = new GlobalCoordinates(
new Angle(Convert.ToDouble(lat2)), new Angle(Convert.ToDouble(lon2))
);
//Calculate the curved distance between the two coordinates
GeodeticCurve geoCurve = geoCalc.CalculateGeodeticCurve(pointA, pointB);
double ellipseMeters = geoCurve.EllipsoidalDistance;
return(ellipseMeters); // return the distance in meters
}
public void TestInverseWithDirect()
{
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
// set Lincoln Memorial coordinates
GlobalCoordinates lincolnMemorial;
lincolnMemorial = new GlobalCoordinates(new Angle(38.88922), new Angle(-77.04978));
// set Eiffel Tower coordinates
GlobalCoordinates eiffelTower;
eiffelTower = new GlobalCoordinates(48.85889, 2.29583);
// calculate the geodetic curve
GeodeticCurve geoCurve = geoCalc.CalculateGeodeticCurve(reference, lincolnMemorial, eiffelTower);
// now, plug the result into to direct solution
GlobalCoordinates dest;
Angle endBearing = new Angle();
dest = geoCalc.CalculateEndingGlobalCoordinates(reference, lincolnMemorial, geoCurve.Azimuth, geoCurve.EllipsoidalDistance, out endBearing);
Assert.AreEqual(eiffelTower.Latitude.Degrees, dest.Latitude.Degrees, 0.0000001);
Assert.AreEqual(eiffelTower.Longitude.Degrees, dest.Longitude.Degrees, 0.0000001);
}
public void TestAntiPodal1()
{
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
// set position 1
GlobalCoordinates p1;
p1 = new GlobalCoordinates(10, 80.6);
// set position 2
GlobalCoordinates p2;
p2 = new GlobalCoordinates(-10, -100);
// calculate the geodetic measurement
GeodeticCurve geoCurve;
geoCurve = geoCalc.CalculateGeodeticCurve(reference, p1, p2);
Assert.AreEqual(19970718.422432076, geoCurve.EllipsoidalDistance, 0.001);
Assert.AreEqual(90.0004877491174, geoCurve.Azimuth.Degrees, 0.0000001);
Assert.AreEqual(270.0004877491174, geoCurve.ReverseAzimuth.Degrees, 0.0000001);
}
/// <summary>
/// Calculate the three-dimensional path from
/// Pike's Peak in Colorado --> 38.840511N, 105.0445896W, 4301 meters
/// to
/// Alcatraz Island --> 37.826389N, 122.4225W, sea level
/// using
/// WGS84 reference ellipsoid
/// </summary>
private static void ThreeDimensionalInverseCalculation()
{
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
// set Pike's Peak position
GlobalPosition pikesPeak = new GlobalPosition(new GlobalCoordinates(Angle.FromDegrees(38.840511), Angle.FromDegrees(-105.0445896)), 4301);
// set Alcatraz Island coordinates
GlobalPosition alcatrazIsland = new GlobalPosition(new GlobalCoordinates(Angle.FromDegrees(37.826389), Angle.FromDegrees(-122.4225)), 0);
// calculate the geodetic measurement
GeodeticMeasurement geoMeasurement;
double p2pKilometers;
double p2pMiles;
double elevChangeMeters;
double elevChangeFeet;
geoMeasurement = geoCalc.CalculateGeodeticMeasurement(reference, pikesPeak, alcatrazIsland);
p2pKilometers = geoMeasurement.PointToPointDistanceMeters / 1000;
p2pMiles = p2pKilometers * 0.621371192;
elevChangeMeters = geoMeasurement.ElevationChangeMeters;
elevChangeFeet = elevChangeMeters * 3.2808399;
Console.WriteLine("3-D path from Pike's Peak to Alcatraz Island using WGS84");
Console.WriteLine(" Point-to-Point Distance: {0:0.00} kilometers ({1:0.00} miles)", p2pKilometers, p2pMiles);
Console.WriteLine(" Elevation change: {0:0.0} meters ({1:0.0} feet)", elevChangeMeters, elevChangeFeet);
Console.WriteLine(" Azimuth: {0:0.00} degrees", geoMeasurement.Azimuth.Degrees);
Console.WriteLine(" Reverse Azimuth: {0:0.00} degrees", geoMeasurement.ReverseAzimuth.Degrees);
}
public void TestCalculateGeodeticMeasurement()
{
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
// set Pike's Peak position
GlobalPosition pikesPeak;
pikesPeak = new GlobalPosition(new GlobalCoordinates(new Angle(38.840511), new Angle(-105.0445896)), 4301.0);
// set Alcatraz Island coordinates
GlobalPosition alcatrazIsland;
alcatrazIsland = new GlobalPosition(new GlobalCoordinates(new Angle(37.826389), new Angle(-122.4225)), 0.0);
// calculate the geodetic measurement
GeodeticMeasurement geoMeasurement;
geoMeasurement = geoCalc.CalculateGeodeticMeasurement(reference, pikesPeak, alcatrazIsland);
Assert.AreEqual(-4301.0, geoMeasurement.ElevationChange, 0.001);
Assert.AreEqual(1521788.826, geoMeasurement.PointToPointDistance, 0.001);
Assert.AreEqual(1521782.748, geoMeasurement.EllipsoidalDistance, 0.001);
Assert.AreEqual(271.21039153, geoMeasurement.Azimuth.Degrees, 0.0000001);
Assert.AreEqual(80.38029386, geoMeasurement.ReverseAzimuth.Degrees, 0.0000001);
}
/// <summary>
/// Get the list of neighbor meshes in a specified "distance". Distance 1 means
/// direct neighbors, 2 means neighbors that are 2 meshes away etc.
/// </summary>
/// <param name="meshNumber">The mesh number</param>
/// <param name="distance">The distance (0-3 currently supported)</param>
/// <returns>The list of mesh numbers of the neighbors</returns>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public List <long> Neighborhood(long meshNumber, int distance)
{
const int maxDistance = 3;
if (distance < 0 || distance > maxDistance)
{
throw new ArgumentOutOfRangeException(Properties.Resources.INVALID_DISTANCE);
}
if (distance == 0)
{
return(new List <long> {
meshNumber
});
}
var center = Projection.FromEuclidian(CenterOf(meshNumber));
var calc = new GeodeticCalculator(Projection.ReferenceGlobe);
var result = new List <long>();
for (var y = -distance; y <= distance; y++)
{
var bearing = Math.Sign(y) < 0 ? 180.0 : 0.0;
var vertical = y != 0 ?
calc.CalculateEndingGlobalCoordinates(center, bearing, Math.Abs(y) * MeshSize)
: center;
for (var x = -distance; x <= distance; x++)
{
if (x != 0 || y != 0)
{
var add = false;
if (Math.Abs(y) == distance)
{
add = true;
}
else
{
if (Math.Abs(x) == distance)
{
add = true;
}
}
if (add)
{
bearing = Math.Sign(x) < 0 ? 270.0 : 90.0;
var horizontal = x != 0 ?
calc.CalculateEndingGlobalCoordinates(vertical, bearing, Math.Abs(x) * MeshSize)
: vertical;
result.Add(MeshNumber(horizontal));
}
}
}
}
return(result);
}
public double MeasureDistance(Coordinates from, Coordinates to)
{
var calculator = new GeodeticCalculator(Ellipsoid.WGS84);
var curve = calculator.CalculateGeodeticCurve(
new GlobalCoordinates(from.Latitude, from.Longitude),
new GlobalCoordinates(to.Latitude, to.Longitude));
return(MetersToMiles(curve.EllipsoidalDistance));
}
public static GeodeticMeasurement CalculateDistance(double lat1, double lon1, double lat2, double lon2)
{
GlobalCoordinates p1 = new GlobalCoordinates(new Angle(lat1), new Angle(lon1));
GlobalCoordinates p2 = new GlobalCoordinates(new Angle(lat2), new Angle(lon2));
GeodeticCalculator gc = new GeodeticCalculator();
GlobalPosition gp1 = new GlobalPosition(p1);
GlobalPosition gp2 = new GlobalPosition(p2);
GeodeticMeasurement gm = gc.CalculateGeodeticMeasurement(Ellipsoid.WGS84, gp1, gp2);
return(gm);
}
public static double GetDistance(double txLat, double txLon, double rxLat, double rxLon)
{
GeodeticCalculator geoCalc = new GeodeticCalculator();
Ellipsoid reference = Ellipsoid.WGS84;
GlobalCoordinates start = new GlobalCoordinates(new Angle(txLat), new Angle(txLon));
GlobalCoordinates end = new GlobalCoordinates(new Angle(rxLat), new Angle(rxLon));
GeodeticCurve path = geoCalc.CalculateGeodeticCurve(reference, start, end);
return(path.EllipsoidalDistance);
}
private void calculateProjection()
{
Framework.Data.Location ll = Utils.Conversion.StringToLocation(textBox3.Text);
if (ll != null)
{
GeodeticCalculator gc = new GeodeticCalculator();
GlobalCoordinates p = gc.CalculateEndingGlobalCoordinates(Ellipsoid.WGS84, new GlobalCoordinates(new Angle(ll.Lat), new Angle(ll.Lon)), new Angle((double)numericUpDown2.Value), radioButton1.Checked ? (double)numericUpDown1.Value : 1609.26939 * (double)numericUpDown2.Value);
textBox4.Text = Utils.Conversion.GetCoordinatesPresentation(p.Latitude.Degrees, p.Longitude.Degrees);
}
else
{
textBox4.Text = "";
}
}
public static void GetEnvelope(double lat, double lon, double dist, out double minLat, out double minLon, out double maxLat, out double maxLon)
{
var gc = new GeodeticCalculator();
var endpoints = new List <GlobalCoordinates>();
endpoints.Add(gc.CalculateEndingGlobalCoordinates(Ellipsoid.WGS84, new GlobalCoordinates(new Angle(lat), new Angle(lon)), new Angle(0), dist * 1000.0));
endpoints.Add(gc.CalculateEndingGlobalCoordinates(Ellipsoid.WGS84, new GlobalCoordinates(new Angle(lat), new Angle(lon)), new Angle(90), dist * 1000.0));
endpoints.Add(gc.CalculateEndingGlobalCoordinates(Ellipsoid.WGS84, new GlobalCoordinates(new Angle(lat), new Angle(lon)), new Angle(180), dist * 1000.0));
endpoints.Add(gc.CalculateEndingGlobalCoordinates(Ellipsoid.WGS84, new GlobalCoordinates(new Angle(lat), new Angle(lon)), new Angle(270), dist * 1000.0));
minLat = endpoints.Min(x => x.Latitude.Degrees);
maxLat = endpoints.Max(x => x.Latitude.Degrees);
minLon = endpoints.Min(x => x.Longitude.Degrees);
maxLon = endpoints.Max(x => x.Longitude.Degrees);
}
public static double NextLat(double lat, double lon, double az, double distance)
{
GeodeticCalculator geoCalc = new GeodeticCalculator();
Ellipsoid reference = Ellipsoid.WGS84;
GlobalCoordinates start = new GlobalCoordinates(new Angle(lat), new Angle(lon));
Angle azimuth = new Angle(az);
Angle endBearing;
GlobalCoordinates dest = geoCalc.CalculateEndingGlobalCoordinates(reference, start, azimuth, distance, out endBearing);
return(dest.Latitude.Degrees);
}
private void addConePolyline(double angle, GeodeticCalculator geoCalculator, CustomMap customMap, LatLng userPos, double distTarget)
{
var polylineOptions = new PolylineOptions();
polylineOptions.Clickable(true);
polylineOptions.InvokeJointType(JointType.Round);
polylineOptions.InvokeWidth(10f);
polylineOptions.InvokeColor(0x664444FF);
polylineOptions.Add(userPos);
LatLng conePoint = movePoint(angle, customMap.UserPin.Position, customMap.TargetPin.Position);
Console.WriteLine("conePoint dist = " + CustomMap.DistanceTo(customMap.UserPin.Position.Latitude, customMap.UserPin.Position.Longitude, conePoint.Latitude, conePoint.Longitude, "M"));
polylineOptions.Add(conePoint);
coneLines.Add(map.AddPolyline(polylineOptions));
}
public static object NextPoint(double lat, double lon, double az, double distance)
{
GeodeticCalculator geoCalc = new GeodeticCalculator();
Ellipsoid reference = Ellipsoid.WGS84;
GlobalCoordinates start = new GlobalCoordinates(new Angle(lat), new Angle(lon));
Angle azimuth = new Angle(az);
Angle endBearing;
GlobalCoordinates dest = geoCalc.CalculateEndingGlobalCoordinates(reference, start, azimuth, distance, out endBearing);
var point = new object[1, 2];
point[0, 0] = dest.Latitude.Degrees;
point[0, 1] = dest.Longitude.Degrees;
return(ArrayResizer.Resize(point));
}
public override object Execute(object[] args, ExecutionContext ctx)
{
string ret = "";
ArgumentChecker checker = new ArgumentChecker(this.GetType().Name);
checker.CheckForNumberOfArguments(ref args, 3, null);
Core.Data.Location ll = Utils.Conversion.StringToLocation(args[0].ToString());
double distance = Utils.Conversion.StringToDouble(args[1].ToString());
double angle = Utils.Conversion.StringToDouble(args[2].ToString());
if (ll != null)
{
GeodeticCalculator gc = new GeodeticCalculator();
GlobalCoordinates p = gc.CalculateEndingGlobalCoordinates(Ellipsoid.WGS84,
new GlobalCoordinates(new Angle(ll.Lat), new Angle(ll.Lon)),
new Angle(angle), distance);
ret = Utils.Conversion.GetCoordinatesPresentation(p.Latitude.Degrees, p.Longitude.Degrees);
}
return(ret);
}
public void UpdateShotCone(double angle)
{
if (coneLines.Count != 0)
{
foreach (Polyline line in coneLines)
{
line.Remove();
}
}
CustomMap customMap = (CustomMap)this.Element;
GeodeticCalculator geoCalculator = new GeodeticCalculator();
double distTarget = 0.0;
LatLng userPos = new LatLng(customMap.UserPin.Position.Latitude, customMap.UserPin.Position.Longitude);
if (customMap != null)
{
distTarget = customMap.getDistanceUserTarget();
addConePolyline(angle, geoCalculator, customMap, userPos, distTarget);
addConePolyline(-angle, geoCalculator, customMap, userPos, distTarget);
}
}
private void SetupLibrary(double gap, double earthRadius, string data, ref List <Point> points)
{
UseDefaultValues();
mode = LibraryMode.Test;
geoCalc = new GeodeticCalculator();
distanceBetweenPoints = gap;
effectiveEarthRadius = earthRadius;
var csv = File.ReadAllLines(data);
points = csv
.Skip(1)
.Select(p => newPointFromCsv(p))
.ToList();
double d = Convert.ToDouble(csv.Last().Split(',')[0]) * 1000.0;
path = new GeodeticCurve(d, new Angle(0.0), new Angle(180.0));
double d_secondLast = Convert.ToDouble(csv[csv.Length - 2].Split(',')[0]) * 1000.0;
distanceBetweenLastPoints = d - d_secondLast;
}
private void btnFind_Click(object sender, EventArgs e)
{
// Store user inputs
int maxRadius = (int)numRadius.Value;
int minRWY = (int)numRWYmin.Value;
int minPCN = (int)numPCNmin.Value;
string[] mustHaveFields = txtIncludeFields.Text.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
// Find home field
AirfieldInformation home = airfieldInfo.Find(x => x.Airfield.ICAO == txtHome.Text);
// instantiate the calculator
GeodeticCalculator geoCalc = new GeodeticCalculator();
// select a reference elllipsoid
Ellipsoid reference = Ellipsoid.WGS84;
foreach (AirfieldInformation alt in airfieldInfo)
{
// calculate the geodetic measurement
GeodeticMeasurement geoMeasurement;
geoMeasurement = geoCalc.CalculateGeodeticMeasurement(reference, home.Airfield.Position, alt.Airfield.Position);
alt.Airfield.RangeFromHome = geoMeasurement.PointToPointDistance * 0.000539957;
alt.Airfield.RadialFromHome = geoMeasurement.Azimuth.Degrees - home.Airfield.MagneticDeclination.Degrees;
}
airfieldInfo.Sort((x, y) => x.Airfield.RangeFromHome.CompareTo(y.Airfield.RangeFromHome));
//Get suitable diverts
List <AirfieldInformation> suitableDiverts = new List <AirfieldInformation>();
for (int z = 0; z < airfieldInfo.Count; z++)
{
//Field is suitable until proven otherwise
bool suitField = true;
if (airfieldInfo[z].Airfield.RangeFromHome > maxRadius)
{
suitField = false;
}
//Runway conditions
bool suitRWY = false;
foreach (Runway r in airfieldInfo[z].Runways)
{
if (r.Length >= minRWY && (r.PCN >= minPCN || r.PCN == -1))
{
suitRWY = true;
}
}
if (!suitRWY)
{
suitField = false;
}
//More options later
if (mustHaveFields.Contains(airfieldInfo[z].Airfield.ICAO))
{
suitField = true;
}
//Add to suitable fields as required
if (suitField)
{
suitableDiverts.Add(airfieldInfo[z]);
}
}
suitableDiverts = import.addSuppAndTerminals(suitableDiverts, flipFileLocation);
//Create pdf
createDivertPDF(suitableDiverts);
}
public DiffractionLossCalculator()
{
geoCalc = new GeodeticCalculator();
try
{
config = ConfigurationManager.OpenExeConfiguration(this.GetType().Assembly.Location);
}
catch (Exception ex)
{
UseDefaultValues();
throw ex;
}
if (config != null)
{
KeyValueConfigurationElement element;
element = config.AppSettings.Settings["distanceBetweenPoints"];
if (element != null)
{
try
{
distanceBetweenPoints = double.Parse(element.Value);
}
catch
{
distanceBetweenPoints = defaultDistanceBetweenPoints;
}
}
element = config.AppSettings.Settings["srtmCache"];
if (element != null)
{
try
{
srtmData = new SRTMData(element.Value);
}
catch
{
srtmData = new SRTMData(defaultSrtmCache);
}
}
element = config.AppSettings.Settings["ellipsoid"];
if (element != null)
{
try
{
switch (element.Value)
{
case "WGS84":
ellipsoid = Ellipsoid.WGS84;
break;
case "GRS80":
ellipsoid = Ellipsoid.GRS80;
break;
case "GRS67":
ellipsoid = Ellipsoid.GRS67;
break;
case "ANS":
ellipsoid = Ellipsoid.ANS;
break;
case "WGS72":
ellipsoid = Ellipsoid.WGS72;
break;
case "Clarke1858":
ellipsoid = Ellipsoid.Clarke1858;
break;
case "Clarke1880":
ellipsoid = Ellipsoid.Clarke1880;
break;
case "Sphere":
ellipsoid = Ellipsoid.Sphere;
break;
default:
ellipsoid = defaultEllipsoid;
break;
}
}
catch
{
ellipsoid = defaultEllipsoid;
}
}
element = config.AppSettings.Settings["effectiveEarthRadius"];
if (element != null)
{
try
{
effectiveEarthRadius = double.Parse(element.Value);
}
catch
{
effectiveEarthRadius = defaultEffectiveEarthRadius;
}
}
}
else
{
UseDefaultValues();
}
}
public LocationDerivation()
{
this.calculator = new GeodeticCalculator(Ellipsoid.WGS84);
}
