public SortGeoDistance(string field, DistanceUnitEnum distanceUnit, GeoPoint geoPoint)
{
_field = field;
Order = OrderEnum.asc;
Unit = distanceUnit;
GeoPoint = geoPoint;
}
public SortGeoDistance(string field, DistanceUnitEnum distanceUnit, List<GeoPoint> geoPoints)
{
_field = field;
Order = OrderEnum.asc;
Unit = distanceUnit;
GeoPoints = geoPoints;
}
public SortGeoDistance(string field, DistanceUnitEnum distanceUnit, GeoPoint geoPoint)
{
_field = field;
Order = OrderEnum.asc;
Unit = distanceUnit;
GeoPoint = geoPoint;
}
public SortGeoDistance(string field, DistanceUnitEnum distanceUnit, List <GeoPoint> geoPoints)
{
_field = field;
Order = OrderEnum.asc;
Unit = distanceUnit;
GeoPoints = geoPoints;
}
/// <summary>
/// Create a distance unit by size and unit.
/// </summary>
/// <param name="size">The numeric value for the distance.</param>
/// <param name="unit">The unit of measure for the distance.</param>
public DistanceValue(Double size, DistanceUnitEnum unit)
{
if (size <= 0)
throw new ArgumentOutOfRangeException("size", "Distance size must be greater than zero.");
if (unit == null)
throw new ArgumentNullException("unit", "Distance unit is required.");
Size = size;
Unit = unit;
}
public string GetDistanceUnitTitle(DistanceUnitEnum distanceUnit)
{
switch (distanceUnit)
{
case DistanceUnitEnum.Kilometers:
return _resources.DistanceUnitKilometers;
case DistanceUnitEnum.Miles:
return _resources.DistanceUnitMiles;
}
return string.Empty;
}
public static double GetDistanceTo(this BasicGeoposition pos1, BasicGeoposition pos2, DistanceUnitEnum type = DistanceUnitEnum.Kilometers)
{
var r = (type == DistanceUnitEnum.Miles) ? 3960 : 6371;
var dLat = ToRadian(pos2.Latitude - pos1.Latitude);
var dLon = ToRadian(pos2.Longitude - pos1.Longitude);
var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
Math.Cos(ToRadian(pos1.Latitude)) * Math.Cos(ToRadian(pos2.Latitude)) *
Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
var c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
var d = r * c;
return d;
}
public string GetDistanceUnitTitle(DistanceUnitEnum distanceUnit)
{
switch (distanceUnit)
{
case DistanceUnitEnum.Kilometers:
return(_resources.DistanceUnitKilometers);
case DistanceUnitEnum.Miles:
return(_resources.DistanceUnitMiles);
}
return(string.Empty);
}
public SettingsViewModel(SettingsService settings, LocalizationService localization)
{
_settings = settings;
_localization = localization;
_distanceUnit = settings.DistanceUnit;
_displayedLocale = settings.CurrentLocale;
_locale = settings.CurrentLocale;
_showExperimentalCities = settings.ShowExperimentalCities;
RaisePropertyChanged(() => Locale);
RaisePropertyChanged(() => LocaleDefaultIndex);
RaisePropertyChanged(() => LanguageChanged);
RaisePropertyChanged(() => ChangeLanguageString);
}
/// <summary>
/// Create a distance value from a string.
/// Unit defaults to meter.
/// </summary>
/// <param name="value"></param>
public DistanceValue(string value)
{
if (value.Contains(DistanceUnitEnum.Centimeter.ToString()))
{
Size = Convert.ToInt64(value.Replace(DistanceUnitEnum.Centimeter.ToString(), string.Empty));
Unit = DistanceUnitEnum.Centimeter;
}
else if (value.Contains(DistanceUnitEnum.Inch.ToString()))
{
Size = Convert.ToInt64(value.Replace(DistanceUnitEnum.Inch.ToString(), string.Empty));
Unit = DistanceUnitEnum.Inch;
}
else if (value.Contains(DistanceUnitEnum.Kilometer.ToString()))
{
Size = Convert.ToInt64(value.Replace(DistanceUnitEnum.Kilometer.ToString(), string.Empty));
Unit = DistanceUnitEnum.Kilometer;
}
else if (value.Contains(DistanceUnitEnum.Mile.ToString()))
{
Size = Convert.ToInt64(value.Replace(DistanceUnitEnum.Mile.ToString(), string.Empty));
Unit = DistanceUnitEnum.Mile;
}
else if (value.Contains(DistanceUnitEnum.Millimeter.ToString()))
{
Size = Convert.ToInt64(value.Replace(DistanceUnitEnum.Millimeter.ToString(), string.Empty));
Unit = DistanceUnitEnum.Millimeter;
}
else if (value.Contains(DistanceUnitEnum.Meter.ToString()))
{
Size = Convert.ToInt64(value.Replace(DistanceUnitEnum.Meter.ToString(), string.Empty));
Unit = DistanceUnitEnum.Meter;
}
else if (value.Contains(DistanceUnitEnum.Yard.ToString()))
{
Size = Convert.ToInt64(value.Replace(DistanceUnitEnum.Yard.ToString(), string.Empty));
Unit = DistanceUnitEnum.Yard;
}
else
{
Int64 sizeValue;
if (Int64.TryParse(value, out sizeValue))
{
Size = sizeValue;
Unit = DistanceUnitEnum.Meter;
}
else
throw new ArgumentException("String cannot be converted into distance precision.");
}
}
public SettingsViewModel(SettingsService settings, LocalizationService localization)
{
_settings = settings;
_localization = localization;
_distanceUnit = settings.DistanceUnit;
_displayedLocale = settings.CurrentLocale;
_locale = settings.CurrentLocale;
_showExperimentalCities = settings.ShowExperimentalCities;
RaisePropertyChanged(() => Locale);
RaisePropertyChanged(() => LocaleDefaultIndex);
RaisePropertyChanged(() => LanguageChanged);
RaisePropertyChanged(() => ChangeLanguageString);
RaisePropertyChanged(() => HasVoiceCommands);
}
/// <summary>
/// Initiate route calculations
/// </summary>
/// <param name="locations">The waypoints of the route (max 25)</param>
/// <param name="displayRoute">Display the route on the map yes or no</param>
/// <param name="setBestMapView">Center the map to have best view of the route yes or no</param>
/// <param name="routeMode">Walking or driving directions</param>
/// <param name="distanceUnit">Miles or kilometers</param>
/// <param name="routeOptimizeFactor">Optimize for minimal time or minimal distance</param>
/// <returns>RouteDirection object </returns>
/// <remarks>If the routeOptimizeFactor is set to Time and the RouteMode is set to walking, then an empty object is returned.</remarks>
public RouteDirections VE_GetDirections(List<SearchLocation> locations, bool displayRoute, bool setBestMapView, RouteModeEnum routeMode, DistanceUnitEnum distanceUnit, RouteOptimizeEnum routeOptimizeFactor)
{
List<SearchLocation> locationsWithLatLongCoordinates = new List<SearchLocation>();
List<SearchLocation> locationsWithoutLatLongCoordinates = new List<SearchLocation>();
if (locations.Count > 25)
{
throw new Exception("Maximum number of waypoints in a route is 25.");
}
// split locations in those with and without latitude and longtidude information
foreach (SearchLocation location in locations)
{
if (location.Latitude != null && location.Longitude != null)
{
locationsWithLatLongCoordinates.Add(location);
}
else
{
locationsWithoutLatLongCoordinates.Add(location);
}
}
// if there are locations without latitude and Longitude information, find the lat/long coordinates using where or what
if (locationsWithoutLatLongCoordinates.Count > 0)
{
VE_FindLocations(locationsWithoutLatLongCoordinates, false, false, null);
while (!finishedFindingLocations)
{
Application.DoEvents();
}
locationsWithLatLongCoordinates.AddRange(this.locations);
}
vEarthBrowser.Document.InvokeScript("clearRouteWaypoints");
// add the waypoints by latitude and Longitude
foreach (SearchLocation searchLocation in locationsWithLatLongCoordinates)
{
if (searchLocation.Latitude != null && searchLocation.Longitude != null)
{
vEarthBrowser.Document.InvokeScript("addRouteWaypoint",
new object[]
{
searchLocation.Longitude,
searchLocation.Latitude
});
}
}
routeDirections = null;
object waypoints = vEarthBrowser.Document.InvokeScript("getDirections", new object[] { displayRoute, setBestMapView, (int)routeMode, distanceUnit, (int)routeOptimizeFactor });
// wait for asynchronous call to getDirections callback function to finish
while (routeDirections == null)
{
Application.DoEvents();
}
return routeDirections;
}
public static double GetDistanceTo(this Geopoint pos1, Geopoint pos2, DistanceUnitEnum type = DistanceUnitEnum.Kilometers)
{
return pos1.Position.GetDistanceTo(pos2.Position, type);
}
public static double GetDistanceTo(this BasicGeoposition pos1, BasicGeoposition pos2, DistanceUnitEnum type = DistanceUnitEnum.Kilometers)
{
var r = (type == DistanceUnitEnum.Miles) ? 3960 : 6371;
var dLat = ToRadian(pos2.Latitude - pos1.Latitude);
var dLon = ToRadian(pos2.Longitude - pos1.Longitude);
var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
Math.Cos(ToRadian(pos1.Latitude)) * Math.Cos(ToRadian(pos2.Latitude)) *
Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
var c = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)));
var d = r * c;
return(d);
}
public static double GetDistanceTo(this Geopoint pos1, Geopoint pos2, DistanceUnitEnum type = DistanceUnitEnum.Kilometers)
{
return(pos1.Position.GetDistanceTo(pos2.Position, type));
}
public SortGeoDistance(string field, DistanceUnitEnum distanceUnit)
{
_field = field;
Order = OrderEnum.asc;
Unit = distanceUnit;
}
/// <summary>
/// This method calculates the distance in miles or kilometers of any two
/// latitude/longitude points by haversine formula. The haversine formula
/// determines the great-circle distance between two points on a sphere
/// given their longitudes and latitudes. Important in navigation, it is
/// a special case of a more general formula in spherical trigonometry,
/// the law of haversines, that relates the
/// sides and angles of spherical triangles.
/// </summary>
/// <param name="pos1">Location 1</param>
/// <param name="pos2">Location 2</param>
/// <param name="unit">Miles or Kilometers</param>
/// <returns>Distance in the requested unit</returns>
public double CalculateDistance(double Latitude1, double Longitude1, double Latitude2, double Longitude2, DistanceUnitEnum unit)
{
double R = (unit == DistanceUnitEnum.Miles) ? 3960 : 6371;
double lat = Commons.ToRadians(Latitude2 - Latitude1);
double lng = Commons.ToRadians(Longitude2 - Longitude1);
double h1 = Math.Sin(lat / 2) * Math.Sin(lat / 2) +
Math.Cos(Commons.ToRadians(Latitude1)) * Math.Cos(Commons.ToRadians(Latitude2)) *
Math.Sin(lng / 2) * Math.Sin(lng / 2);
double h2 = 2 * Math.Asin(Math.Min(1, Math.Sqrt(h1)));
return(R * h2);
}