/// <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 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; }
/// <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);