/// <summary> /// Initializes a new instance of the <see cref="Distance"/> class /// using the data read from persistent storage. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> internal Distance(EditDeserializer editDeserializer) { double distance = editDeserializer.ReadDouble(DataField.Value); DistanceUnitType unitType = (DistanceUnitType)editDeserializer.ReadByte(DataField.Unit); m_EnteredUnit = EditingController.GetUnits(unitType); m_ObservedMetric = m_EnteredUnit.ToMetric(distance); if (editDeserializer.IsNextField(DataField.Fixed)) { m_IsFixed = editDeserializer.ReadBool(DataField.Fixed); } else { m_IsFixed = false; } if (editDeserializer.IsNextField(DataField.Flipped)) { IsAnnotationFlipped = editDeserializer.ReadBool(DataField.Flipped); } else { IsAnnotationFlipped = false; } }
private void AdjustmentForm_Shown(object sender, EventArgs e) { // Display at top left corner of the screen. this.Location = new Point(0, 0); // Display the adjustment results in the current data entry units. DistanceUnitType unitType = EditingController.Current.Project.Settings.EntryUnitType; if (unitType == DistanceUnitType.Feet) { OnFeet(); } else if (unitType == DistanceUnitType.Chains) { OnChains(); } else { OnMeters(); } if (Math.Abs(m_Precision) < MathConstants.TINY) { precisionLabel.Text = "exact"; } else { precisionLabel.Text = String.Format("1:{0:0.0}", m_Precision); } }
void ShowResults(DistanceUnitType dunit) { DistanceUnit unit = EditingController.GetUnits(dunit); lengthTextBox.Text = unit.Format(m_Length); totalEnteredTextBox.Text = unit.Format(m_Entered); lengthLeftTextBox.Text = unit.Format(m_Length - m_Entered); }
public UserMeasurementUnitMetric(float rawValue, DistanceUnitType rawDistanceUnitType, DistanceUnitType userSelectedDistanceUnitType) : this(rawValue) { _rawValue = rawValue; _rawDistanceUnitType = rawDistanceUnitType; _userSelectedDistanceUnitType = userSelectedDistanceUnitType; CalculateFormattedValue(); }
public async Task SetDistanceUnitTypeAsync(DistanceUnitType distanceUnitType) { await LoadSettingsAsync(createIfNotExisting : true); _settings.DistanceUnitType = distanceUnitType; await SaveSettingsToStorageAsync(); }
/// <summary> /// Converts distance unit type to a string. /// </summary> /// <param name="dut">Distance unit to convert.</param> /// <returns>A string version of the distance unit.</returns> internal static string DistanceUnitTypeToString(DistanceUnitType dut) { if (dut == DistanceUnitType.Miles) { return("mile"); } return("kilometer"); }
public void SetUserMeasurementUnits(DistanceUnitType measurementUnit) { MeasurementUnit = measurementUnit; bool isMetric = MeasurementHelper.IsMetric(MeasurementUnit); var elevationDistanceUnitType = MeasurementHelper.GetElevationUnitType(isMetric); var distanceUnitType = MeasurementHelper.GetDistanceUnitType(isMetric); TotalDistanceUserMeasurementUnit = new UserMeasurementUnitMetric((float)Distance, DistanceUnitType.Metres, distanceUnitType); ElevationGainUserMeasurementUnit = new UserMeasurementUnitMetric((float)ElevationGain, DistanceUnitType.Metres, elevationDistanceUnitType); }
public static double DistanceInMiles(double distance, DistanceUnitType unit) { if (unit == DistanceUnitType.Kilometers) { return(UnitConverter.KilometersToMiles(distance)); } else { return(distance); } }
/// <summary> /// Retrieves the radius of the earth in a specific distance unit for WGS84. /// </summary> /// <param name="units">Unit of distance measurement.</param> /// <returns>The radius of the earth in a specified distance units.</returns> public static double GetEarthRadius(DistanceUnitType units) { switch (units) { case DistanceUnitType.Miles: return(EarthRadius.Miles); case DistanceUnitType.KM: default: return(EarthRadius.KM); } }
/// <summary> /// Retrieves the radius of the earth in a specific distance unit for WGS84. /// </summary> /// <param name="units">Unit of distance measurement.</param> /// <returns>The radius of the earth in a specified distance units.</returns> internal static double GetEarthRadius(DistanceUnitType units) { switch (units) { case DistanceUnitType.Miles: return(EarthRadius.Miles); case DistanceUnitType.Kilometers: default: return(EarthRadius.KM); } }
void ShowResults(DistanceUnitType type) { DistanceUnit unit = EditingController.GetUnits(type); if (unit == null) { return; } lengthLabel.Text = unit.Format(m_Length, false, -1); deltaNorthingLabel.Text = unit.Format(m_DeltaN, false, -1); deltaEastingLabel.Text = unit.Format(m_DeltaE, false, -1); }
/// <summary> /// Converts distances from one unit to another. /// </summary> /// <param name="distance">The distance to convert</param> /// <param name="fromUnits">The units of the distance.</param> /// <param name="toUnits">The units to convert to.</param> /// <returns>Distance converted to the specified units.</returns> public static double ConvertDistance(double distance, DistanceUnitType fromUnits, DistanceUnitType toUnits) { //Convert the distance to kilometers switch (fromUnits) { case DistanceUnitType.Meters: distance /= 1000; break; case DistanceUnitType.Feet: distance /= 3288.839895; break; case DistanceUnitType.Miles: distance *= 1.609344; break; case DistanceUnitType.Yards: distance *= 0.0009144; break; case DistanceUnitType.Kilometers: break; } //Convert from kilometers to output distance unit switch (toUnits) { case DistanceUnitType.Meters: distance *= 1000; break; case DistanceUnitType.Feet: distance *= 5280; break; case DistanceUnitType.Miles: distance /= 1.609344; break; case DistanceUnitType.Yards: distance *= 1093.6133; break; case DistanceUnitType.Kilometers: break; } return(distance); }
private async Task ViewLoaded() { _loading = true; DistanceUnitType distanceUnitType = await _settingsService.GetStoredDistanceUnitTypeAsync(); SelectedMeasurementUnit = distanceUnitType.ToString(); ActivitySort activitySort = await _settingsService.GetStoredActivitySortAsync(); SelectedSortType = activitySort.ToString(); _loading = false; }
public static float ConvertDistance(float value, DistanceUnitType fromUnit, DistanceUnitType toUnit) { float workingValue; if (fromUnit == DistanceUnitType.Metres) workingValue = value; else workingValue = value / DistanceConversions[(int)fromUnit]; if (toUnit != DistanceUnitType.Metres) workingValue = workingValue * DistanceConversions[(int)toUnit]; return workingValue; }
RadioButton GetDisplayRadioButton(DistanceUnitType unitType) { switch (unitType) { case DistanceUnitType.Meters: return displayMetersRadioButton; case DistanceUnitType.Feet: return displayFeetRadioButton; case DistanceUnitType.Chains: return displayChainsRadioButton; case DistanceUnitType.AsEntered: return displayAsEnteredRadioButton; } throw new ArgumentException(); }
RadioButton GetEntryRadioButton(DistanceUnitType unitType) { switch (unitType) { case DistanceUnitType.Meters: return(enterMetersRadioButton); case DistanceUnitType.Feet: return(enterFeetRadioButton); case DistanceUnitType.Chains: return(enterChainsRadioButton); } throw new ArgumentException(); }
/// <summary> /// Create a distance unit with the specified type. /// </summary> /// <param name="unitType">The type of unit to create.</param> internal DistanceUnit(DistanceUnitType unitType) { switch (unitType) { case DistanceUnitType.AsEntered: { m_UnitCode = unitType; m_UnitName = String.Empty; m_Abbreviation = String.Empty; m_Multiplier = 1.0; m_Colour = Color.White; break; } case DistanceUnitType.Feet: { m_UnitCode = unitType; m_UnitName = "Feet"; m_Abbreviation = "ft"; m_Multiplier = 0.3048; m_Colour = Color.Red; break; } case DistanceUnitType.Chains: { m_UnitCode = unitType; m_UnitName = "Chains"; m_Abbreviation = "ch"; m_Multiplier = 20.1168; m_Colour = Color.Green; break; } case DistanceUnitType.Meters: default: { m_UnitCode = unitType; m_UnitName = "Meters"; m_Abbreviation = "m"; m_Multiplier = 1.0; m_Colour = Color.Black; break; } } }
public async Task SetDistanceUnitType(DistanceUnitType distanceUnitType) { if (_settings == null) { bool settingsExists = await this.SettingsServiceExists(); if (settingsExists) { string settingsAsString = await ServiceLocator.Current.GetInstance<IStorageService>().Local.ReadAllTextAsync(Constants.SETTINGSSTORE); _settings = JsonConvert.DeserializeObject<Settings>(settingsAsString); } else _settings = new Settings(); } _settings.DistanceUnitType = distanceUnitType; await ServiceLocator.Current.GetInstance<IStorageService>().Local.WriteAllTextAsync(Constants.SETTINGSSTORE, JsonConvert.SerializeObject(_settings)); }
internal static DistanceUnit GetUnits(DistanceUnitType unitType) { switch (unitType) { case DistanceUnitType.Meters: return(s_Meters); case DistanceUnitType.Feet: return(s_Feet); case DistanceUnitType.Chains: return(s_Chains); case DistanceUnitType.AsEntered: return(s_AsEntered); } throw new ArgumentException("Unexpected unit type"); }
RadioButton GetDisplayRadioButton(DistanceUnitType unitType) { switch (unitType) { case DistanceUnitType.Meters: return(displayMetersRadioButton); case DistanceUnitType.Feet: return(displayFeetRadioButton); case DistanceUnitType.Chains: return(displayChainsRadioButton); case DistanceUnitType.AsEntered: return(displayAsEnteredRadioButton); } throw new ArgumentException(); }
public static float ConvertDistance(float value, DistanceUnitType fromUnit, DistanceUnitType toUnit) { float workingValue; if (fromUnit == DistanceUnitType.Metres) { workingValue = value; } else { workingValue = value / DistanceConversions[(int)fromUnit]; } if (toUnit != DistanceUnitType.Metres) { workingValue = workingValue * DistanceConversions[(int)toUnit]; } return(workingValue); }
/// <summary> /// Converts distances from miles to km or km to miles. /// </summary> /// <param name="distance">Distance to convert.</param> /// <param name="fromUnits">The units that the distance is in.</param> /// <param name="toUnits">The units to convert the distance to.</param> /// <returns>A distance in the specified unit of measurement.</returns> public static double ConvertDistance(double distance, DistanceUnitType fromUnits, DistanceUnitType toUnits) { if (fromUnits == toUnits || double.IsNaN(distance)) { return(distance); } //Convert the distance to kilometers if (fromUnits == DistanceUnitType.Miles) { distance *= 1.609344; } if (toUnits == DistanceUnitType.Miles) { distance *= 0.62137119; } return(distance); }
/// <summary> /// Default constructor (for serialization mechanism) /// </summary> public ProjectSettings() { m_ConnectionString = String.Empty; m_DrawInfo = new DrawInfo(0.0, 0.0, 0.0); m_DisplayUnit = DistanceUnitType.AsEntered; m_EntryUnit = DistanceUnitType.Meters; m_AutoNumber = true; m_ShowLabelScale = 2000.0; m_ShowPointScale = 2000.0; m_PointHeight = 2.0; m_AreIntersectionsDrawn = false; m_MapScale = 2000; m_Annotation = new LineAnnotationStyle(); m_IsChanged = false; m_DefaultPointType = 0; m_DefaultLineType = 0; m_DefaultPolygonType = 0; m_DefaultTextType = 0; m_SplashIncrement = String.Empty; m_SplashPercents = String.Empty; }
/// <summary> /// Retrieves the radius of the earth in a specific distance unit for WGS84. Defaults unit is in Meters. /// </summary> /// <param name="units">Unit of distance measurement</param> /// <returns>A double that represents the radius of the earth in a specific distance unit. Defaults unit is in KM's.</returns> public static double GetEarthRadius(DistanceUnitType units) { switch (units) { case DistanceUnitType.Feet: return(EarthRadius.Feet); case DistanceUnitType.Meters: return(EarthRadius.Meters); case DistanceUnitType.Miles: return(EarthRadius.Miles); case DistanceUnitType.Yards: return(ConvertDistance(EarthRadius.KM, DistanceUnitType.Kilometers, DistanceUnitType.Yards)); case DistanceUnitType.Kilometers: default: return(EarthRadius.KM); } }
private async Task ViewLoaded() { _loading = true; DistanceUnitType distanceUnitType = await _settingsService.GetStoredDistanceUnitTypeAsync(); SelectedMeasurementUnit = distanceUnitType.ToString(); ActivitySort activitySort = await _settingsService.GetStoredActivitySortAsync(); SelectedSortType = activitySort.ToString(); var appInfoList = await _settingsService.GetAppInfoAsync(); CurrentVersion = appInfoList.FirstOrDefault(); //TODO: Glenn - refactor initialization in settings service? While converting json to class? if (CurrentVersion.Features != null) { InfoOverviewItem features = new InfoOverviewItem() { Header = "Features", Items = new ObservableCollection <string>(CurrentVersion.Features) }; CurrentVersion.OverviewItems.Add(features); } if (CurrentVersion.BugFixes != null) { InfoOverviewItem bugFixes = new InfoOverviewItem() { Header = "Bug fixes", Items = new ObservableCollection <string>(CurrentVersion.BugFixes) }; CurrentVersion.OverviewItems.Add(bugFixes); } await Task.Run(GetMapSizes); _loading = false; }
/// <summary> /// Reads a distance unit type. /// </summary> /// <param name="field">A tag associated with the item</param> /// <returns>The distance unit that was read.</returns> internal DistanceUnit ReadDistanceUnit(DataField field) { DistanceUnitType unitType = (DistanceUnitType)m_Reader.ReadInt32(field.ToString()); return(EditingController.GetUnits(unitType)); }
/// <summary>Calculates a destination coordinate given a starting coordinate, bearing, and distance in KM's.</summary> /// <param name="origin" type="Coordinate">Initial location.</param> /// <param name="brng" type="Number">Bearing pointing towards new location.</param> /// <param name="arcLength" type="Number">A distance in KM's.</param> /// <param name="units" type="DistanceUnitType">Unit of measurement of the arcLength</param> /// <returns>A destination coordinate based on an origin point, bearing and distance.</returns> public static Coordinate CalculateCoord(Coordinate origin, double brng, double arcLength, DistanceUnitType units) { double earthRadius = GetEarthRadius(units); double lat1 = ToRadians(origin.Latitude), lon1 = ToRadians(origin.Longitude), centralAngle = arcLength / earthRadius; var lat2 = Math.Asin(Math.Sin(lat1) * Math.Cos(centralAngle) + Math.Cos(lat1) * Math.Sin(centralAngle) * Math.Cos(ToRadians(brng))); var lon2 = lon1 + Math.Atan2(Math.Sin(ToRadians(brng)) * Math.Sin(centralAngle) * Math.Cos(lat1), Math.Cos(centralAngle) - Math.Sin(lat1) * Math.Sin(lat2)); return(new Coordinate() { Latitude = ToDegrees(lat2), Longitude = ToDegrees(lon2) }); }
/// <summary> /// Calculate the distance between two coordinates on the surface of a sphere (Earth). /// </summary> /// <param name="origLat">Origin Latitude.</param> /// <param name="origLon">Origin Longitude.</param> /// <param name="destLat">Destination Latitude.</param> /// <param name="destLon">Destination Longitude.</param> /// <param name="units">Unit of distance measurement.</param> /// <returns>The shortest distance in the specifed units.</returns> public static double HaversineDistance(double origLat, double origLon, double destLat, double destLon, DistanceUnitType units) { double radius = GetEarthRadius(units); double dLat = ToRadians(destLat - origLat); double dLon = ToRadians(destLon - origLon); double a = Math.Pow(Math.Sin(dLat / 2), 2) + Math.Pow(Math.Cos(ToRadians(origLat)), 2) * Math.Pow(Math.Sin(dLon / 2), 2); double centralAngle = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a)); return(radius * centralAngle); }
/// <summary> /// Calculate the distance between two coordinates on the surface of a sphere (Earth). /// </summary> /// <param name="origin">First coordinate to calculate distance between.</param> /// <param name="destination">Second coordinate to calculate distance between.</param> /// <param name="units">Unit of distance measurement.</param> /// <returns>The shortest distance in the specifed units.</returns> public static double HaversineDistance(Coordinate origin, Coordinate destination, DistanceUnitType units) { return(HaversineDistance(origin.Latitude, origin.Longitude, destination.Latitude, destination.Longitude, units)); }
void SetUnit(DistanceUnitType type) { m_Unit = EditingController.GetUnits(type); }
RadioButton GetEntryRadioButton(DistanceUnitType unitType) { switch (unitType) { case DistanceUnitType.Meters: return enterMetersRadioButton; case DistanceUnitType.Feet: return enterFeetRadioButton; case DistanceUnitType.Chains: return enterChainsRadioButton; } throw new ArgumentException(); }
void ShowResults(DistanceUnitType type) { DistanceUnit unit = EditingController.GetUnits(type); if (unit==null) return; lengthLabel.Text = unit.Format(m_Length, false, -1); deltaNorthingLabel.Text = unit.Format(m_DeltaN, false, -1); deltaEastingLabel.Text = unit.Format(m_DeltaE, false, -1); }
//TODO: Glenn - Should we set these at some SegmentBaseClass? public static void SetMetricUnits(SegmentEffort segment, DistanceUnitType distanceUnitType) { segment.DistanceUnit = distanceUnitType; }
//TODO: Glenn - Should we set these at some SegmentBaseClass? public static void SetMetricUnits(SegmentSummary segment, DistanceUnitType distanceUnitType) { segment.DistanceUnit = distanceUnitType; }
internal static DistanceUnit GetUnits(DistanceUnitType unitType) { switch (unitType) { case DistanceUnitType.Meters: return s_Meters; case DistanceUnitType.Feet: return s_Feet; case DistanceUnitType.Chains: return s_Chains; case DistanceUnitType.AsEntered: return s_AsEntered; } throw new ArgumentException("Unexpected unit type"); }
/// <summary> /// Creates a NxN distance matrix with straight line distances. /// </summary> /// <param name="waypoints">The waypoints to generate a matrix for.</param> /// <param name="distanceUnits">The distance units to calculate the distances in.</param> /// <param name="bingMapsKey">A bing maps key that can be used to geocode waypoints, if needed.</param> /// <returns>A NxN distance matrix with straight line distances.</returns> public static async Task <DistanceMatrix> CreateStraightLineNxNMatrix(List <SimpleWaypoint> waypoints, DistanceUnitType distanceUnits, string bingMapsKey) { //Ensure all the waypoints are geocoded. if (waypoints == null || waypoints.Count < 2) { throw new Exception("Not enough Waypoints specified."); } if (!string.IsNullOrEmpty(bingMapsKey)) { await SimpleWaypoint.TryGeocodeWaypoints(waypoints, bingMapsKey); } var numWaypoints = waypoints.Count; var cells = new DistanceMatrixCell[numWaypoints * numWaypoints]; await Task.Run(() => Parallel.For(0, numWaypoints, i => { for (var j = 0; j < numWaypoints; j++) { double distance = -1; if (i != j && waypoints[i].Coordinate != null && waypoints[j].Coordinate != null) { distance = SpatialTools.HaversineDistance(waypoints[i].Coordinate, waypoints[j].Coordinate, distanceUnits); } cells[i * numWaypoints + j] = new DistanceMatrixCell() { OriginIndex = i, DestinationIndex = j, TravelDistance = distance }; } })); return(new DistanceMatrix() { Origins = waypoints, Destinations = waypoints, Results = cells }); }
public static void SetMetricUnits(ActivitySummary activity, DistanceUnitType distanceUnitType) { activity.DistanceUnit = distanceUnitType; activity.SpeedUnit = activity.DistanceUnit == DistanceUnitType.Kilometres ? SpeedUnit.KilometresPerHour : SpeedUnit.MilesPerHour; activity.ElevationUnit = activity.DistanceUnit == DistanceUnitType.Kilometres ? DistanceUnitType.Metres : DistanceUnitType.Feet; }