/// <summary>
/// Sets country code for this distance this looks up appropriate full name (kilometer or mile)
/// </summary>
/// <param name="localeCode">Full locale code(en-US) or only country code (CA) for this distance</param>
/// <returns>Lower cased full name for distance unit (kilometer or mile)</returns>
public string LocaleName(string localeCode)
{
CountryCode = localeCode;
switch (SystemType)
{
case MeasurementType.Imperial: return(DistanceSpan.Name(this, DistanceType.Mile));
default:
return(DistanceSpan.Name(this, DistanceType.Kilometer));
}
}
/// <summary>
/// Compare two distance objects
/// </summary>
/// <param name="d1">Distance to compare</param>
/// <param name="d2">Distance to compare</param>
/// <returns>Returns 1,0,-1 depending on comparision</returns>
public static int Compare(DistanceSpan d1, DistanceSpan d2)
{
if (d1._meters > d2._meters)
{
return(1);
}
if (d1._meters < d2._meters)
{
return(-1);
}
return(0);
}
/// <summary>
/// Sets country code for this distance then looks up appropriate unit of measurement (mi or km)
/// </summary>
/// <param name="localeCode">Full locale code(en-US) or only country code (CA) for this distance</param>
/// <returns>Two character lower cased abbreviation for localized distance unit</returns>
public string LocaleUnits(string localeCode)
{
CountryCode = localeCode;
if (SystemType == MeasurementType.Imperial)
{
return(DistanceSpan.Unit(DistanceType.Mile));
}
else
{
return(DistanceSpan.Unit(DistanceType.Kilometer));
}
}
/// <summary>
/// Parse a string into a DistanceSpan
/// </summary>
/// <param name="distance">String of valid numeric characters for meters</param>
/// <param name="result">Newly created DistanceSpan if successful</param>
/// <returns>True if parsing was successful.</returns>
public static bool TryParse(string distance, out DistanceSpan result)
{
try
{
result = new DistanceSpan(double.Parse(distance, CultureInfo.InvariantCulture), DistanceType.Meter);
return(true);
}
catch
{
result = DistanceSpan.Zero;
return(false);
}
}
/// <summary>
/// Calculate a bounding box that is a certain size
/// </summary>
/// <param name="distance">Size of box</param>
/// <param name="center">Center of box</param>
/// <param name="minimum">One corner of bounding box</param>
/// <param name="maximum">Opposite corner of bounding box</param>
public static void Radius(DistanceSpan distance, Coordinate center, out Coordinate minimum, out Coordinate maximum)
{
double radius = double.NaN;
radius = distance.TotalKilometers;
double latitude = center.Latitude.TotalSeconds;
double longitude = center.Longitude.TotalSeconds;
double maxLat = latitude + radius / GeoConstant.EQUATOR_LAT_KILOMETERS;
double minLat = latitude - (maxLat - latitude);
double maxLong = longitude + radius / (Math.Cos(minLat * Math.PI / 180) * GeoConstant.EQUATOR_LAT_KILOMETERS);
double minLong = longitude - (maxLong - longitude);
minimum = new Coordinate(minLat, minLong);
maximum = new Coordinate(maxLat, maxLong);
}
/// <summary>
/// Calculates the distance between two lat/long pairs
/// </summary>
/// <param name="dblLat1">Start Latitude</param>
/// <param name="dblLong1">Start Longitude</param>
/// <param name="dblLat2">Stop Latitude</param>
/// <param name="dblLong2">Stop Longitude</param>
/// <returns>Distance span object</returns>
public static DistanceSpan Distance(double dblLat1, double dblLong1, double dblLat2, double dblLong2)
{
//convert degrees to radians
dblLat1 = dblLat1 * Math.PI / 180;
dblLong1 = dblLong1 * Math.PI / 180;
dblLat2 = dblLat2 * Math.PI / 180;
dblLong2 = dblLong2 * Math.PI / 180;
double dist = 0;
if (dblLat1 != dblLat2 || dblLong1 != dblLong2)
{
//the two points are not the same
dist =
Math.Sin(dblLat1) * Math.Sin(dblLat2)
+ Math.Cos(dblLat1) * Math.Cos(dblLat2)
* Math.Cos(dblLong2 - dblLong1);
dist =
GeoConstant.EARTH_RADIUS_KILOMETERS
* (-1 * Math.Atan(dist / Math.Sqrt(1 - dist * dist)) + Math.PI / 2);
}
return(DistanceSpan.FromKilometers(dist));
}
/// <summary>
/// Calculate a bounding box that is a certain size
/// </summary>
/// <param name="distance">Size of box</param>
/// <param name="center">Center of box</param>
/// <param name="minimum">One corner of bounding box</param>
/// <param name="maximum">Opposite corner of bounding box</param>
public static void Radius(DistanceSpan distance, Coordinate center, out Coordinate minimum, out Coordinate maximum)
{
double radius = double.NaN;
radius = distance.TotalKilometers;
double latitude = center.Latitude.TotalSeconds ;
double longitude = center.Longitude.TotalSeconds ;
double maxLat = latitude + radius / GeoConstant.EQUATOR_LAT_KILOMETERS;
double minLat = latitude - (maxLat - latitude);
double maxLong = longitude + radius / (Math.Cos(minLat * Math.PI / 180) * GeoConstant.EQUATOR_LAT_KILOMETERS);
double minLong = longitude - (maxLong - longitude);
minimum = new Coordinate(minLat, minLong);
maximum = new Coordinate(maxLat, maxLong);
}
/// <summary>
/// Compare two distance spans
/// </summary>
/// <param name="d1">First distance span to compare</param>
/// <param name="d2">Second distanc span to compare</param>
/// <returns>True if both spans represent the same value; otherwise false</returns>
public static bool Equals(DistanceSpan d1, DistanceSpan d2)
{
return(Compare(d1, d2) == 0);
}
/// <summary>
/// Compare a distance span to this span
/// </summary>
/// <param name="distance">Distance span to compare</param>
/// <returns>True if they represent the same internal value</returns>
public bool Equals(DistanceSpan distance)
{
return(Equals(this, distance));
}
/// <summary>
/// Compare a distance object to this object. 1 if this is greater than distance; else 0 or -1
/// </summary>
/// <param name="distance">Distance to compare</param>
/// <returns>1 if this is greater than distance; else 0 or -1</returns>
public int CompareTo(DistanceSpan distance)
{
return(Compare(this, distance));
}
/// <summary>
/// Add a value to this span
/// </summary>
/// <param name="distance">Distance to add</param>
/// <returns>New span that is sum of current and parameter</returns>
public DistanceSpan Add(DistanceSpan distance)
{
return(new DistanceSpan(_meters + distance._meters));
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="span">Span to copy</param>
public DistanceSpan(DistanceSpan span)
{
_meters = span._meters;
_countryCode = span.CountryCode;
}
/// <summary>
/// Returns the full unit name (in English) for a particular distance span (kilometer, feet, mile)
/// </summary>
/// <param name="distance">Distance value to get name for</param>
/// <param name="distanceType">Distance type to get name for</param>
/// <returns>Lower case full name for a distance type</returns>
public static string Name(DistanceSpan distance, DistanceType distanceType)
{
return((Math.Abs(distance._meters) < 1)?_nameSingular[(int)distanceType]:_namePlural[(int)distanceType]);
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="span">Span to copy</param>
public DistanceSpan(DistanceSpan span)
{
_meters = span._meters;
_countryCode = span.CountryCode;
}
/// <summary>
/// Displays the value of this span. Use one of the format prefixes to determine output value and format. See
/// notes for important formatting details
/// </summary>
/// <param name="format">Format argument as provided in the string.Format call</param>
/// <param name="formatProvider">Format provider as passed in the string.Format call</param>
/// <returns>Formatted value of this span</returns>
/// <example>
/// <para></para>
/// <para>Uppercase values display entire word. Lowercase values display abbreviation</para>
/// <para>{0:^KM} ==> 1.345 kilometers</para>
/// <para>{0:^km} ==> 1.345 km</para>
/// <para>{0:^MI} ==> 1.345 miles</para>
/// <para>{0:^MI} ==> 1.345 mi</para>
/// <para></para>
/// <para><b>String Format Codes</b></para>
/// <para>^(KM,km) kilometers, km</para>
/// <para>^(M,m) meters, m</para>
/// <para>^(CM,cm) centimeters, m</para>
/// <para>^(MM,mm) millimeters, mm</para>
/// <para>^(MI,mi) miles, mi.</para>
/// <para>^(YD,yd) yards, yd.</para>
/// <para>^(FT,ft) feet, ft.</para>
/// <para>^(IN,in) inches, in.</para>
/// <para>^(NM,nm) nautical, nm.</para>
/// <para></para>
/// <para>^(Km) return kilometers without unit identifier (e.g. km)</para>
/// <para>^(Cm) return centimeters without unit identifier</para>
/// <para>^() no distance span specified but delimiter '^' optionally is. Return meters</para>
/// <para>^(Mm) return millimeters without unit identifier</para>
/// <para>^(Mi) return miles without unit identifier</para>
/// <para>^(Yd) return yards without unit identifier</para>
/// <para>^(Ft) return feet without unit identifier</para>
/// <para>^(In) return Inches without unit identifier</para>
/// <para>^(Nm) return nautical miles without unit identifer</para>
/// <para><b>Numerical Formatting</b></para>
/// <para>You can change the default numerical formatting by supplying .Net standard numerical formatting codes in front of the abbreviation suffix</para>
/// <para></para>
/// <para>{0:00#.00K} to display leading zeros => 001.20 kilometers</para>
/// </example>
/// <remarks>Formatting codes had to be chosen not to conflict with existing numerical formatting codes</remarks>
public string ToString(string format, IFormatProvider formatProvider)
{
if (string.IsNullOrEmpty(format) == true)
{
return(_meters.ToString(formatProvider));
}
string[] aParts = format.Split(new char[] { '^' });
if (aParts.Length < 2) // distance span delimiter '^' not specified so just use default numeric formatting and return meters
{
return(string.Format(formatProvider, format, TotalMeters)); //return value in meters (default)
}
string sFormat = "{0";
if (string.IsNullOrEmpty(aParts[0]) == false)
{
sFormat += ":" + aParts[0];
}
sFormat += "}";
switch (aParts[1])
{
case "KM": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Name(this, DistanceType.Kilometer), TotalKilometers));
case "km": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Abbreviation(DistanceType.Kilometer), TotalKilometers));
case "M": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Name(this, DistanceType.Meter), TotalMeters));
case "m": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Abbreviation(DistanceType.Meter), TotalMeters));
case "CM": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Name(this, DistanceType.Centimeter), TotalCentimeters));
case "cm": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Abbreviation(DistanceType.Centimeter), TotalCentimeters));
case "MM": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Name(this, DistanceType.Millimeter), TotalMillimeters));
case "mm": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Abbreviation(DistanceType.Millimeter), TotalMillimeters));
case "MI": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Name(this, DistanceType.Mile), TotalMiles));
case "mi": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Abbreviation(DistanceType.Mile), TotalMiles));
case "YD": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Name(this, DistanceType.Yard), TotalYards));
case "yd": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Abbreviation(DistanceType.Yard), TotalYards));
case "FT": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Name(this, DistanceType.Foot), TotalFeet));
case "ft": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Abbreviation(DistanceType.Foot), TotalFeet));
case "IN": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Name(this, DistanceType.Inch), TotalInches));
case "in": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Abbreviation(DistanceType.Inch), TotalInches));
case "NM": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Name(this, DistanceType.MileNautical), TotalNauticalMiles));
case "nm": return(string.Format(formatProvider, sFormat + " " + DistanceSpan.Abbreviation(DistanceType.MileNautical), TotalNauticalMiles));
case "Km": return(string.Format(formatProvider, sFormat, TotalKilometers));
case "": return(string.Format(formatProvider, sFormat, TotalMeters));
case "Cm": return(string.Format(formatProvider, sFormat, TotalCentimeters));
case "Mm": return(string.Format(formatProvider, sFormat, TotalMillimeters));
case "Mi": return(string.Format(formatProvider, sFormat, TotalMiles));
case "Yd": return(string.Format(formatProvider, sFormat, TotalYards));
case "Ft": return(string.Format(formatProvider, sFormat, TotalFeet));
case "In": return(string.Format(formatProvider, sFormat, TotalInches));
case "Nm": return(string.Format(formatProvider, sFormat, TotalNauticalMiles));
}
throw new FormatException(string.Format("Unable to display requested format: '{0}'", format));
}
/// <summary>
/// Calculate a bounding square that is a certain width and height.
/// </summary>
/// <param name="distance">Width/Height of bounding box</param>
/// <param name="minimum">Returns one corner of bounding box</param>
/// <param name="maximum">Returns opposite corner of bounding box</param>
public void Radius(DistanceSpan distance, out Coordinate minimum, out Coordinate maximum)
{
Radius(distance, this, out minimum, out maximum);
}
/// <summary>
/// Constructor to create a distance span
/// </summary>
/// <param name="value">Value of distance length</param>
/// <param name="distanceType">Type of distance value represents (miles, meters, yards, etc.)</param>
public DistanceSpan(double value, DistanceSpan.DistanceType distanceType)
{
_meters = ToMetric(value, distanceType);
_countryCode = string.Empty;
}
/// <summary>
/// Subtract a distance from this DistanceSpan
/// </summary>
/// <param name="distance">Distance to shorten this DistanceSpan by</param>
/// <returns>New DistanceSpan</returns>
public DistanceSpan Subtract(DistanceSpan distance)
{
return(this.Add(distance.TotalMeters * -1D));
}
/// <summary>
/// Parse a string into a DistanceSpan
/// </summary>
/// <param name="distance">String of valid numeric characters</param>
/// <param name="distanceType">Type of distance represents (miles, feet, etc)</param>
/// <param name="result">Newly created DistanceSpan if successful</param>
/// <returns>True if parsing was successful.</returns>
public static bool TryParse(string distance, DistanceSpan.DistanceType distanceType, out DistanceSpan result)
{
try
{
result = new DistanceSpan(double.Parse(distance, CultureInfo.InvariantCulture), distanceType);
}
catch
{
result = DistanceSpan.Zero;
return false;
}
return true;
}
/// <summary>
/// Subtract a distance from this DistanceSpan
/// </summary>
/// <param name="distance">Distance to shorten this DistanceSpan by</param>
/// <returns>New DistanceSpan</returns>
public DistanceSpan Subtract(DistanceSpan distance)
{
return this.Add(distance.TotalMeters * -1D);
}
/// <summary>
/// Calculate a bounding square that is a certain width and height.
/// </summary>
/// <param name="distance">Width/Height of bounding box</param>
/// <param name="minimum">Returns one corner of bounding box</param>
/// <param name="maximum">Returns opposite corner of bounding box</param>
public void Radius(DistanceSpan distance, out Coordinate minimum, out Coordinate maximum)
{
Radius(distance, this, out minimum, out maximum);
}
/// <summary>
/// Compare two distance spans
/// </summary>
/// <param name="d1">First distance span to compare</param>
/// <param name="d2">Second distanc span to compare</param>
/// <returns>True if both spans represent the same value; otherwise false</returns>
public static bool Equals(DistanceSpan d1, DistanceSpan d2) { return (Compare(d1, d2) == 0); }
/// <summary>
/// Subtract a distance from this DistanceSpan
/// </summary>
/// <param name="value">Value to shorten DistanceSpan by</param>
/// <param name="distanceType">Type of distance value represents (miles, feet, etc)</param>
/// <returns>New DistanceSpan</returns>
public DistanceSpan Subtract(double value, DistanceSpan.DistanceType distanceType)
{
return this.Add(value * -1D, distanceType);
}
/// <summary>
/// Compare a distance object to this object. 1 if this is greater than distance; else 0 or -1
/// </summary>
/// <param name="distance">Distance to compare</param>
/// <returns>1 if this is greater than distance; else 0 or -1</returns>
public int CompareTo(DistanceSpan distance)
{
return Compare(this, distance);
}
/// <summary>
/// Compare a distance span to this span
/// </summary>
/// <param name="distance">Distance span to compare</param>
/// <returns>True if they represent the same internal value</returns>
public bool Equals(DistanceSpan distance)
{
return Equals(this, distance);
}
/// <summary>
/// Compare two distance objects
/// </summary>
/// <param name="d1">Distance to compare</param>
/// <param name="d2">Distance to compare</param>
/// <returns>Returns 1,0,-1 depending on comparision</returns>
public static int Compare(DistanceSpan d1, DistanceSpan d2)
{
if (d1._meters > d2._meters) return 1;
if (d1._meters < d2._meters) return -1;
return 0;
}
/// <summary>
/// Add a value to this span
/// </summary>
/// <param name="distance">Distance to add</param>
/// <returns>New span that is sum of current and parameter</returns>
public DistanceSpan Add(DistanceSpan distance)
{
return new DistanceSpan(_meters + distance._meters);
}
/// <summary>
/// Add a value to this span
/// </summary>
/// <param name="value">Distance to add</param>
/// <param name="distanceType">Type of distance to add (kilometers, miles, inches)</param>
/// <returns>New span that is sum of current and parameter</returns>
public DistanceSpan Add(double value, DistanceSpan.DistanceType distanceType)
{
return new DistanceSpan(_meters + ToMetric(value, distanceType));
}
/// <summary>
/// Convert a distance from one type to another
/// </summary>
/// <param name="value">Distance to convert</param>
/// <param name="inputType">Type that value represents</param>
/// <param name="outputType">Target type the return value represents</param>
/// <returns>Converted distance that is of outputType</returns>
public static double Convert(double value, DistanceSpan.DistanceType inputType, DistanceType outputType)
{
return FromMetric(ToMetric(value, inputType), outputType);
}
/// <summary>
/// Returns the full unit name (in English) for a particular distance span (kilometer, feet, mile)
/// </summary>
/// <param name="distance">Distance value to get name for</param>
/// <param name="distanceType">Distance type to get name for</param>
/// <returns>Lower case full name for a distance type</returns>
public static string Name(DistanceSpan distance, DistanceType distanceType)
{
return (Math.Abs(distance._meters)<1)?_nameSingular[(int)distanceType]:_namePlural[(int)distanceType];
}
