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