/// <summary>
/// Get distance between two points
/// </summary>
/// <param name="location"></param>
/// <returns></returns>
public double DistanceFrom(GeoLocation location, DistanceUnits distanceUnits = DistanceUnits.NauticalMiles)
{
if (!HasLocation)
{
return(0);
}
double phi_s = Latitude.Value.ToRadians(),
lamda_s = Longitude.Value.ToRadians(),
phi_f = location.Latitude.Value.ToRadians(),
lamda_f = location.Longitude.Value.ToRadians();
// using vincenty formula
double y = Math.Sqrt(Math.Pow((Math.Cos(phi_f) * Math.Sin(lamda_s - lamda_f)), 2) + Math.Pow((Math.Cos(phi_s) *
Math.Sin(phi_f) - Math.Sin(phi_s) * Math.Cos(phi_f) * Math.Cos(lamda_s - lamda_f)), 2));
double x = Math.Sin(phi_s) * Math.Sin(phi_f) + Math.Cos(phi_s) * Math.Cos(phi_f) * Math.Cos(lamda_s - lamda_f);
double delta = Math.Atan2(y, x);
var nm = delta.ToDegrees() * 60;
switch (distanceUnits)
{
case DistanceUnits.Kilometers: return(nm * 1.852);
case DistanceUnits.Meters: return(nm * 1852);
case DistanceUnits.Miles: return(nm * 1.15077945);
}
return(nm);
}
public string AreaToString(DistanceUnits unit, int decimalPlaces)
{
double num = Width.In(unit) * Height.In(unit);
decimalPlaces = Range.Range.clamp(decimalPlaces, 0, 10);
return(string.Format("{0} {1}", num.ToString("N" + decimalPlaces), areaUnitLut[unit]));
}
/// <summary>
///Calculates the distance between two lat/lng's in miles or meters.
/// </summary>
/// <param name="ll2">Second lat,lng position to calculate distance to.</param>
/// <param name="lUnits">Units to calculate distance, defaults to miles</param>
/// <returns>Returns the distance in meters or miles</returns>
public double ArcDistance(LatLng ll2, DistanceUnits lUnits)
{
LatLng ll1 = Normalize();
ll2 = ll2.Normalize();
double lat1 = ll1.GetLat(), lng1 = ll1.GetLng();
double lat2 = ll2.GetLat(), lng2 = ll2.GetLng();
// Check for same position
if (lat1 == lat2 && lng1 == lng2)
return 0.0;
// Get the m_dLongitude difference. Don't need to worry about
// crossing 180 since cos(x) = cos(-x)
double dLon = lng2 - lng1;
double a = Radians(90.0 - lat1);
double c = Radians(90.0 - lat2);
double cosB = (Math.Cos(a) * Math.Cos(c))
+ (Math.Sin(a) * Math.Sin(c) * Math.Cos(Radians(dLon)));
double radius = (lUnits == DistanceUnits.MILES) ? 3963.205 /* MILERADIUSOFEARTH */ : 6378.160187
/* KMRADIUSOFEARTH */;
// Find angle subtended (with some bounds checking) in radians and
// multiply by earth radius to find the arc distance
if (cosB < -1.0) return MathHelper.PI * radius;
if (cosB >= 1.0) return 0;
return Math.Acos(cosB) * radius;
}
public static string UnitsToString(this DistanceUnits distanceUnit, string format)
{
switch (format.ToLower())
{
case "a": // plural...i.e. x miles
case "abbrv":
switch (distanceUnit)
{
case DistanceUnits.Miles:
return("miles");
case DistanceUnits.Kilometers:
return("km");
}
break;
case "a.s": // singular...i.e. min/mile
case "abbrv.s":
switch (distanceUnit)
{
case DistanceUnits.Miles:
return("mile");
case DistanceUnits.Kilometers:
return("km");
}
break;
}
return(distanceUnit.ToString());
}
public double GetByUnit(DistanceUnits distanceUnits)
{
switch (distanceUnits)
{
case DistanceUnits.Meters:
return(InMeters);
case DistanceUnits.Kilometers:
return(InKilometers);
case DistanceUnits.Miles:
return(InMiles);
case DistanceUnits.Feet:
return(InFeet);
case DistanceUnits.Inches:
return(InInches);
case DistanceUnits.Centimeter:
return(InCentimeters);
case DistanceUnits.Yards:
return(InYards);
case DistanceUnits.Millimeter:
return(InMillimeter);
default:
throw new ArgumentException($"Distance units {distanceUnits} is not known");
}
}
public static string GetUnitsSymbol(DistanceUnits distanceUnits)
{
switch (distanceUnits)
{
case DistanceUnits.Meters:
return("m");
case DistanceUnits.Kilometers:
return("Km");
case DistanceUnits.Miles:
return("mi");
case DistanceUnits.Feet:
return("ft");
case DistanceUnits.Inches:
return("in");
case DistanceUnits.Centimeter:
return("cm");
case DistanceUnits.Yards:
return("yd");
case DistanceUnits.Millimeter:
return("mm");
default:
throw new ArgumentException($"Distance units {nameof(distanceUnits)} is unknown.");
}
}
public static Distance CreateByUnits(double value, DistanceUnits distanceUnits)
{
switch (distanceUnits)
{
case DistanceUnits.Meters:
return(FromMeters(value));
case DistanceUnits.Kilometers:
return(FromMeters(value * 1000));
case DistanceUnits.Miles:
return(FromMeters(value * 1609.34));
case DistanceUnits.Feet:
return(FromMeters(value * 0.3047992424196));
case DistanceUnits.Yards:
return(FromMeters(value * 0.9144));
case DistanceUnits.Inches:
return(FromMeters(value * 0.0254));
case DistanceUnits.Centimeter:
return(FromMeters(value / 100));
case DistanceUnits.Millimeter:
return(FromMeters(value / 1000));
default:
throw new ArgumentException($"Distance units {nameof(distanceUnits)} is unknown.");
}
}
/// <summary>
/// Asks the user to input a distance, which is then converted into the unit
/// they selected at the start, and the result is
/// displayed on-screen.
/// </summary>
public void ConvertDistance()
{
ConsoleHelper.OutputHeading("Distance Conversion Calculator");
FromUnit = SelectUnit("From Unit");
ToUnit = SelectUnit("To Unit");
/// If the user has selected the From and To units with the same
/// choice, an error message will appear and will keep doing so
/// until they choose a different To unit.
while (ToUnit == FromUnit)
{
Console.WriteLine("\tThe To unit cannot be the same as " +
"the From unit. Please try again.\n");
ToUnit = SelectUnit("To Unit");
}
Console.WriteLine($"\t{FromUnit} -> {ToUnit} Conversion");
FromDistance = ConsoleHelper.InputNumber($"\tPlease enter the number of {FromUnit} > ");
CalculateDistance();
OutputDistance();
ExitDecision();
}
public Distance(Control c, DistanceOrientation o, DistanceUnits u, double v)
{
this.control = c;
this.orientation = o;
this.units = u;
this.val = v;
}
public static double CalculateDistance(
double latitudeStart,
double latitudeEnd,
double longitudeStart,
double longitudeEnd,
DistanceUnits units)
{
if (latitudeEnd == latitudeStart && longitudeEnd == longitudeStart)
{
return(0);
}
var rlat1 = PI * latitudeStart / 180.0;
var rlat2 = PI * latitudeEnd / 180.0;
var theta = longitudeStart - longitudeEnd;
var rtheta = PI * theta / 180.0;
var dist = (Sin(rlat1) * Sin(rlat2)) + (Cos(rlat1) * Cos(rlat2) * Cos(rtheta));
dist = Acos(dist);
dist = dist * 180.0 / PI;
var final = dist * 60.0 * 1.1515;
if (double.IsNaN(final) || double.IsInfinity(final) || double.IsNegativeInfinity(final) ||
double.IsPositiveInfinity(final) || final < 0)
{
return(0);
}
if (units == DistanceUnits.Kilometers)
{
return(MilesToKilometers(final));
}
return(final);
}
protected virtual DistanceUnits?NextSmallerUnit(DistanceUnits unit)
{
switch (unit)
{
case DistanceUnits.ImpInches:
return(null);
case DistanceUnits.ImpFeet:
return(DistanceUnits.ImpInches);
case DistanceUnits.ImpMils:
return(null);
case DistanceUnits.ImpMiles:
return(DistanceUnits.ImpFeet);
case DistanceUnits.Metres:
return(DistanceUnits.CentiMetres);
case DistanceUnits.CentiMetres:
return(DistanceUnits.MilliMetres);
case DistanceUnits.MilliMetres:
return(null);
case DistanceUnits.KiloMetres:
return(DistanceUnits.Metres);
default:
return(null);
}
}
public Distance(double distance, DistanceUnits units)
{
var calculator = new DistanceCalculator();
var distanceData = new DistanceData {
DistanceM = distance, DistanceKm = distance
};
switch (units)
{
case DistanceUnits.Miles:
distanceData.Calc = "kilometers";
break;
case DistanceUnits.Kilometers:
distanceData.Calc = "miles";
break;
default:
throw new ArgumentException("Unknown units: " + units, "units");
}
calculator.Calculate(distanceData);
DistanceInM = distanceData.DistanceM.Value;
DistanceInKm = distanceData.DistanceKm.Value;
BaseDistance = distance;
BaseUnits = units;
}
public static Distance FromDistance(double val, DistanceUnits units)
{
Distance d = new Distance();
d.Metres = val / GetPerMetreConversion(units);
return(d);
}
private void SetDistanceUnits(DistanceUnits units)
{
this.DistanceUnits = units;
Config.SetUser <DistanceUnits>(PluginManager.Instance.User, "Gazetteer.NearestNamePlace.DistanceUnits", units);
mnuKilometers.IsChecked = units == Utilities.DistanceUnits.Kilometers;
mnuMiles.IsChecked = units == Utilities.DistanceUnits.Miles;
}
public string ToString(DistanceUnits unit, bool longVersion)
{
double num = this.In(unit);
string units = longVersion ? DistanceUnitInfo.GetPreferedLongUnitString(unit) : DistanceUnitInfo.GetPreferedShortUnitString(unit);
return(string.Format("{0} {1}", num, units));
}
private Distance ConvertUnits(DistanceUnits units)
{
if (this.units == units)
{
return(this);
}
double newValue;
switch (units)
{
case DistanceUnits.Miles:
newValue = value * ConversionConstant;
break;
case DistanceUnits.Kilometers:
newValue = value / ConversionConstant;
break;
default:
newValue = 0;
break;
}
return(new Distance(newValue, units));
}
public static double GetPerMetreConversion(DistanceUnits units)
{
switch (units)
{
case DistanceUnits.ImpInches:
return(InchesPerMetre);
case DistanceUnits.ImpFeet:
return(FeetPerMetre);
case DistanceUnits.ImpMils:
return(MilsPerMetre);
case DistanceUnits.ImpMiles:
return(MilesPereMetre);
case DistanceUnits.Metres:
return(1);
case DistanceUnits.CentiMetres:
return(CentiMetresPerMetre);
case DistanceUnits.MilliMetres:
return(MilliMetresPerMetre);
case DistanceUnits.KiloMetres:
return(KiloMetresPerMetre);
}
WDAppLog.LogNeverSupposedToBeHere();
return(1);//wtf
}
/// <summary>
/// Ask the user for the unit in which they want to convert into another.
/// </summary>
/// <param name="prompt"></param>
/// <returns></returns>
private DistanceUnits SelectUnit(string prompt)
{
string choice = DisplayChoices(prompt);
DistanceUnits unit = ExecuteChoice(choice);
return(unit);
}
public Distance(Control c, DistanceOrientation o, DistanceUnits u, double v)
{
this.control = c;
this.orientation = o;
this.units = u;
this.val = v;
}
public dynamic CreateUser(string authId, string originalHost, DistanceUnits currentDistanceUnits)
{
var userAccount = new UserAccount().Insert(new { DisplayName = "", CreatedDate = DateTime.UtcNow, LastActivityDate = DateTime.UtcNow, OriginalHostAddress = originalHost, UserType = "N", DistanceUnits = currentDistanceUnits });
new UserAccountAuthentication().Insert(new { UserAccountId = userAccount.Id, Identifier = authId });
return(userAccount);
}
public Distance(
double value,
DistanceUnits units)
{
Value = Math.Round(value, 8);
Units = units;
}
public static List<WeatherDetail> GetDetails (WuLocation location, TemperatureUnits temp, SpeedUnits speed, LengthUnits length, DistanceUnits distance, PressureUnits pressure)
{
var list = new List<WeatherDetail> ();
for (int i = 0; i < Count; i++) list.Add (GetDetail (i, location, temp, speed, length, distance, pressure));
return list;
}
///<summary>
/// Method allows the result to be output.
///</summary>
public static void OutputResult(double distF, DistanceUnits unitF,
double distT, DistanceUnits unitT)
{
Console.Write(distF);
Console.Write(" " + unitF + " is ");
Console.Write(distT);
Console.WriteLine(" " + unitT);
}
public static WeatherDetail GetDetail (int row, WuLocation location, TemperatureUnits temp, SpeedUnits speed, LengthUnits length, DistanceUnits distance, PressureUnits pressure)
{
return new WeatherDetail {
DetailLabel = GetLabel (row),
DetailValue = GetValue (row, location, temp, speed, length, distance, pressure),
IsSectionTop = IsSectionTop (row)
};
}
public static double Convert(double valueToConvert, DistanceUnits startUnit, DistanceUnits endUnit)
{
//value as meters
double meterValue = ConvertToMeter(startUnit, valueToConvert);
//value as final unit
double finalValue = ConvertMeterTo(endUnit, meterValue);
return(Math.Round(finalValue, 2));
}
public static double Convert(double valueToConvert, DistanceUnits startUnit, DistanceUnits endUnit)
{
//value as meters
double meterValue = ConvertToMeter(startUnit, valueToConvert);
//value as final unit
double finalValue = ConvertMeterTo(endUnit, meterValue);
return Math.Round(finalValue, 2);
}
private static void AddMetricViaPrefix(string prefix, DistanceUnits unit)
{
unitsTable.Add(new DistanceUnitInfo(unit, prefix + "metres"));
unitsTable.Add(new DistanceUnitInfo(unit, prefix + "metre"));
unitsTable.Add(new DistanceUnitInfo(unit, prefix + " metre"));
unitsTable.Add(new DistanceUnitInfo(unit, prefix + "-metre"));
unitsTable.Add(new DistanceUnitInfo(unit, prefix + " metres"));
unitsTable.Add(new DistanceUnitInfo(unit, prefix + "-metres"));
}
protected GridUnitModeImperial(DistanceUnits from, DistanceUnits?to,
int decimalPlaces, int fractionDenominator,
bool useLowestTerms, bool rulerMode)
: base(from, to, decimalPlaces, rulerMode)
{
this.fractionDenominator = fractionDenominator;
this.useLowestTerms = useLowestTerms;
InterUnitSeperator = "";
}
/// <summary>
/// This method will Input the distance in miles
/// calculate the same distance in feet, and output the
/// distance in feet.
/// </summary>
public void ConvertDistance()
{
string[] choices = new string[]
{
FEET, METERS, MILES
};
int choice;
Console.WriteLine("Select the distance unit to convert from >");
choice = ConsoleHelper.SelectChoice(choices);
FromUnit = ExecuteChoice(choice);
if (choice == 1)
{
Console.WriteLine("You have selected Feet");
}
else if (choice == 2)
{
Console.WriteLine("You have selected Meters");
}
else if (choice == 3)
{
Console.WriteLine("You have selected Miles");
}
Console.WriteLine("Select the distance unit to convert to >");
choice = ConsoleHelper.SelectChoice(choices);
ToUnit = ExecuteChoice(choice);
if (choice == 1)
{
Console.WriteLine("You have selected Feet");
}
else if (choice == 2)
{
Console.WriteLine("You have selected Meters");
}
else if (choice == 3)
{
Console.WriteLine("You have selected Miles");
}
ConsoleHelper.OutputHeading($"Converting {FromUnit} to {ToUnit}");
FromDistance = ConsoleHelper.InputNumber($"Please enter the number of {FromUnit} > ");
CalculateDistance();
OutputDistance();
}
public Distance DistanceBetween(Location location, DistanceUnits units)
{
double num = (units == DistanceUnits.Miles) ? 3956.545 : 6378.2;//3438.147;
double num2 = this.ToRadian(location.Latitude - this.Latitude);
double num3 = this.ToRadian(location.Longitude - this.Longitude);
double d = Math.Pow(Math.Sin(num2 / 2.0), 2.0) + ((Math.Cos(this.ToRadian(this.Latitude)) * Math.Cos(this.ToRadian(location.Latitude))) * Math.Pow(Math.Sin(num3 / 2.0), 2.0));
double num5 = 2.0 * Math.Asin(Math.Min(1.0, Math.Sqrt(d)));
return new Distance(num * num5, units);
}
public Distance DistanceBetween(Location location, DistanceUnits units)
{
double num = (units == DistanceUnits.Miles) ? 3956.545 : 6378.2;//3438.147;
double num2 = this.ToRadian(location.Latitude - this.Latitude);
double num3 = this.ToRadian(location.Longitude - this.Longitude);
double d = Math.Pow(Math.Sin(num2 / 2.0), 2.0) + ((Math.Cos(this.ToRadian(this.Latitude)) * Math.Cos(this.ToRadian(location.Latitude))) * Math.Pow(Math.Sin(num3 / 2.0), 2.0));
double num5 = 2.0 * Math.Asin(Math.Min(1.0, Math.Sqrt(d)));
return(new Distance(num * num5, units));
}
/// <summary>
/// Asks the user to select their choices (source and destination distance units for conversion)
/// and then executes the conversion.
/// </summary>
/// <param name="prompt">The user's selected choice.</param>
/// <returns>The execution of the user's choice.</returns>
public DistanceUnits SelectUnit(string prompt)
{
int choice = ShowChoices(prompt);
DistanceUnits unit = ExecuteChoice(choice);
Console.WriteLine($"\t{unit} has been selected.\n");
return(unit);
}
private static double ConvertToMeter(DistanceUnits origUnit, double value)
{
if (Rule.Rules.ContainsKey(origUnit))
{
return value/Rule.Rules[origUnit];
}
else
{
throw new Exception("Invalid unit");
}
}
private static double ConvertToMeter(DistanceUnits origUnit, double value)
{
if (Rule.Rules.ContainsKey(origUnit))
{
return(value / Rule.Rules[origUnit]);
}
else
{
throw new Exception("Invalid unit");
}
}
private static double ConvertMeterTo(DistanceUnits destUnit, double value)
{
if (Rule.Rules.ContainsKey(destUnit))
{
return(value * Rule.Rules[destUnit]);
}
else
{
throw new Exception("Invalid unit");
}
}
private static double ConvertMeterTo(DistanceUnits destUnit, double value)
{
if (Rule.Rules.ContainsKey(destUnit))
{
return value*Rule.Rules[destUnit];
}
else
{
throw new Exception("Invalid unit");
}
}
public void ConvertDistance()
{
ConsoleHelper.OutputHeading("Distance Converter", 0.6);
FromUnit = SelectUnit(" Please select the 'from' distance unit: ");
ToUnit = SelectUnit(" Please select the 'to' distance unit: ");
Console.WriteLine($"\n Convert {FromUnit} to {ToUnit}");
FromDistance = InputDistance($" Please enter the number of {FromUnit}: ");
CalculateDistance();
OutputDistance();
}
private string GetDistanceUnits(DistanceUnits units)
{
if (units == null)
{
return("imperial");
}
if (units != 1)
{
throw new NotSupportedException();
}
return("metric");
}
public Distance ConvertTo(DistanceUnits toUnits)
{
switch (toUnits)
{
case DistanceUnits.Miles:
if (this.BaseUnits == DistanceUnits.Miles) return this;
return new Distance(this.DistanceInM, DistanceUnits.Miles);
case DistanceUnits.Kilometers:
if (this.BaseUnits == DistanceUnits.Kilometers) return this;
return new Distance(this.DistanceInKm, DistanceUnits.Kilometers);
default:
return this;
}
}
public virtual Distance DistanceBetween(Location location, DistanceUnits units)
{
double earthRadius = (units == DistanceUnits.Miles) ? Distance.EarthRadiusInMiles : Distance.EarthRadiusInKilometers;
double latRadian = ToRadian(location.Latitude - this.Latitude);
double longRadian = ToRadian(location.Longitude - this.Longitude);
double a = Math.Pow(Math.Sin(latRadian / 2.0), 2) +
Math.Cos(ToRadian(this.Latitude)) *
Math.Cos(ToRadian(location.Latitude)) *
Math.Pow(Math.Sin(longRadian / 2.0), 2);
double c = 2.0 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
double distance = earthRadius * c;
return new Distance(distance, units);
}
public Distance(double value, DistanceUnits type)
{
switch (type)
{
case DistanceUnits.KILOMETERS:
this._value = value * Distance.KILOMETERS_TO_METERS;
break;
case DistanceUnits.AU:
this._value = value * Distance.AU_TO_METERS;
break;
case DistanceUnits.AE:
this._value = value * Distance.AE_TO_METERS;
break;
default:
this._value = value;
break;
}
}
private Distance ConvertUnits(DistanceUnits units)
{
if (this.units == units) return this;
double newValue;
switch (units)
{
case DistanceUnits.Miles:
newValue = value * ConversionConstant;
break;
case DistanceUnits.Kilometers:
newValue = value / ConversionConstant;
break;
default:
newValue = 0;
break;
}
return new Distance(newValue, units);
}
public static string GetValue (int row, WuLocation location, TemperatureUnits temp, SpeedUnits speed, LengthUnits length, DistanceUnits distance, PressureUnits pressure)
{
var conditions = location?.Conditions;
if (conditions == null) return string.Empty;
switch (row) {
case 0: return conditions.FeelsLikeString (temp, true, true);
case 1: return location.SunriseString ();
case 2: return location.SunsetString ();
case 3: return location.ProbabilityPercipString ();
case 4: return conditions.relative_humidity;
case 5: return conditions.WindString (speed);
case 6: return conditions.GustString (speed);
case 7: return conditions.PrecipTodayString (length);
case 8: return conditions.PressureString (pressure);
case 9: return conditions.VisibilityString (distance);
case 10: return location.Conditions.UV.ToString ();
default: return string.Empty;
}
}
/// <summary>
/// Returns distance in requested units
/// </summary>
/// <param name="units">distance units to use</param>
/// <returns>distance</returns>
public int GetDistance(DistanceUnits units)
{
//Set Write mode 'ON'
_pin.Active = true;
_pin.Write(true);
_pin.Write(false);
//Set Read mode 'ON'
_pin.Active = false;
bool high = false;
//Wait for start of the echo pulse.
do
{
high = _pin.Read();
}
while (!high);
//Measure current time
long startTime = System.DateTime.Now.Ticks;
// Wait for end of echo pulse.
while (high)
{
high = _pin.Read();
}
//Get total ticks accounting for roundtrip
int ticks = (int)(System.DateTime.Now.Ticks - startTime)>>1;
int microSeconds = ticks / TicksPerMicrosecond;
if( units == DistanceUnits.Inches )
return microSeconds * 1000 / TO_INCH;
else if( units == DistanceUnits.Centimeters)
return microSeconds * 1000 / TO_CM;
else
return microSeconds * 10000 / TO_CM;
}
public Distance(double distance, DistanceUnits units)
{
var calculator = new DistanceCalculator();
var distanceData = new DistanceData { DistanceM = distance, DistanceKm = distance };
switch (units)
{
case DistanceUnits.Miles:
distanceData.Calc = "kilometers";
break;
case DistanceUnits.Kilometers:
distanceData.Calc = "miles";
break;
default:
throw new ArgumentException("Unknown units: " + units, "units");
}
calculator.Calculate(distanceData);
DistanceInM = distanceData.DistanceM.Value;
DistanceInKm = distanceData.DistanceKm.Value;
BaseDistance = distance;
BaseUnits = units;
}
/// <summary>
/// Convert the millimeters into other units.
/// </summary>
/// <param name="metres">The Ping))) sensor's m reading.</param>
/// <param name="outputUnit">The desired output unit.</param>
public double Convert(double metres, DistanceUnits outputUnit)
{
double result = metres;
switch (outputUnit)
{
case DistanceUnits.mm:
result = metres * 1000F;
break;
case DistanceUnits.cm:
result = metres * 100F;
break;
case DistanceUnits.dm:
result = metres * 10F;
break;
case DistanceUnits.inch:
result = metres * 39.3700787;
break;
case DistanceUnits.feet:
result = metres * 3.2808399;
break;
case DistanceUnits.yard:
result = metres * 1.0936133;
break;
}
return result;
}
/// <remarks/>
public void ReverseGeocode_BinaryAsync(string inLocatorId, string matchTerm, Point point, int inputCoordinateSystem, double maximumSearchRadius, DistanceUnits distanceUnits, int maximumCount, int returnCoordinateSystem, object userState) {
if ((this.ReverseGeocode_BinaryOperationCompleted == null)) {
this.ReverseGeocode_BinaryOperationCompleted = new System.Threading.SendOrPostCallback(this.OnReverseGeocode_BinaryOperationCompleted);
}
this.InvokeAsync("ReverseGeocode_Binary", new object[] {
inLocatorId,
matchTerm,
point,
inputCoordinateSystem,
maximumSearchRadius,
distanceUnits,
maximumCount,
returnCoordinateSystem}, this.ReverseGeocode_BinaryOperationCompleted, userState);
}
public Distance(double value, DistanceUnits units)
{
this._value = Math.Round(value, 8);
this._units = units;
}
private Distance ConvertUnits(DistanceUnits units)
{
double num;
if (this._units == units)
{
return this;
}
switch (units)
{
case DistanceUnits.Miles:
num = this._value * 0.621371192;
break;
case DistanceUnits.Kilometers:
num = this._value / 0.621371192;
break;
default:
num = 0.0;
break;
}
return new Distance(num, units);
}
public static void SetUnitsForRegion(RegionInfo regionInfo)
{
var isMetric = regionInfo == null || regionInfo.IsMetric;
UserDistanceUnit = isMetric ? DistanceUnits.Kilometer : DistanceUnits.Mile;
UserUnitOfMeasure = isMetric ? FillupUnits.Litres : FillupUnits.UsGallons;
}
public byte[] ReverseGeocode_Binary(string inLocatorId, string matchTerm, Point point, int inputCoordinateSystem, double maximumSearchRadius, DistanceUnits distanceUnits, int maximumCount, int returnCoordinateSystem) {
object[] results = this.Invoke("ReverseGeocode_Binary", new object[] {
inLocatorId,
matchTerm,
point,
inputCoordinateSystem,
maximumSearchRadius,
distanceUnits,
maximumCount,
returnCoordinateSystem});
return ((byte[])(results[0]));
}
/// <summary>
/// Returns the distance between two points on a curved plane with an assumed mean radius of 6371.1 KM (Earth)
/// </summary>
/// <param name="fLat1">Y1</param>
/// <param name="fLong1">X1</param>
/// <param name="fLat2">Y2</param>
/// <param name="fLong2">X2</param>
/// <param name="units">Miles or Kilometres</param>
/// <returns></returns>
public static double GreatCircleArcLength(double fLat1, double fLong1, double fLat2, double fLong2, DistanceUnits units)
{
const double dfPi = Math.PI;
double dfRadLat1 = fLat1 * (dfPi / 180);
double dfRadLat2 = fLat2 * (dfPi / 180);
double dfRadDeltaLong = (fLong2 - fLong1) * (dfPi / 180);
double dfCosZ = Math.Sin(dfRadLat1) * Math.Sin(dfRadLat2) + Math.Cos(dfRadLat1) * Math.Cos(dfRadLat2) * Math.Cos(dfRadDeltaLong);
if (Math.Abs(dfCosZ - 1.0) < 0.0000000001) {
// The points were very close together
return 0;
} else {
double dfDiv = Math.Sqrt((dfCosZ * -1) * dfCosZ + 1);
if (dfDiv == 0) {
return 0;
} else {
double dfACosZ = Math.Atan((dfCosZ * -1) / dfDiv) + 1.5708;
switch (units) {
case DistanceUnits.Kilometers:
return dfACosZ * (float)6371.1; // Mean radius of Earth is 6371.1 KM
case DistanceUnits.Miles:
return dfACosZ * (float)3959; // Mean radius of Earth is 3959 Miles
case DistanceUnits.None:
return dfACosZ; // Users can apply their own Mean Radius to get different units
default:
throw new Exception("Unhandled distance unit type: " + units.ToString());
}
}
}
}
/// <remarks/>
public void ReverseGeocode_BinaryAsync(string inLocatorId, string matchTerm, Point point, int inputCoordinateSystem, double maximumSearchRadius, DistanceUnits distanceUnits, int maximumCount, int returnCoordinateSystem) {
this.ReverseGeocode_BinaryAsync(inLocatorId, matchTerm, point, inputCoordinateSystem, maximumSearchRadius, distanceUnits, maximumCount, returnCoordinateSystem, null);
}
public virtual Distance DistanceBetween(Address address, DistanceUnits units)
{
return this.Coordinates.DistanceBetween(address.Coordinates, units);
}
private void SetDistanceUnits(DistanceUnits units)
{
this.DistanceUnits = units;
Config.SetUser<DistanceUnits>(PluginManager.Instance.User, "Gazetteer.NearestNamePlace.DistanceUnits", units);
mnuKilometers.IsChecked = units == Utilities.DistanceUnits.Kilometers;
mnuMiles.IsChecked = units == Utilities.DistanceUnits.Miles;
}
public string ToString(DistanceUnits units)
{
double val = 0.0;
string suffix = "";
switch (units)
{
case DistanceUnits.AE:
val = this.AE;
suffix = " AE";
break;
case DistanceUnits.AU:
val = this.AU;
suffix = " AU";
break;
case DistanceUnits.KILOMETERS:
val = this.Kilometers;
suffix = " Km";
break;
default:
val = this.Meters;
suffix = " m";
break;
}
string s = val.ToString("#.00000000") + suffix;
return s;
}
public static string VisibilityString (this CurrentObservation observation, DistanceUnits units, bool round = false) => getValueStringInUnits (observation.Visibility (units, round), units);
static string getValueStringInUnits (double value, DistanceUnits unit)
=> $"{value} {unit.getUnitString ()}";
public static double Visibility (this CurrentObservation observation, DistanceUnits units, bool round = false) => getValueInUnits (units, observation?.visibility_mi, observation?.visibility_km, round);
static double getValueInUnits (DistanceUnits units, double? imperial, double? metric, bool round = false) => getValueInUnits (units.IsImperial (), imperial, metric, round);
