public GeoPoint(float lat, float lon, float alt, GeoCalculator.DistanceUnits altUnit = GeoCalculator.DistanceUnits.Kilofeet)
{
_lat = lat;
_lon = lon;
switch (altUnit)
{
case GeoCalculator.DistanceUnits.Feet:
this._alt = (float)GeoCalculator.ConvertDistanceUnit(alt, GeoCalculator.DistanceUnits.Feet, GeoCalculator.DistanceUnits.Degrees);
break;
case GeoCalculator.DistanceUnits.Kilofeet:
this._alt = (float)GeoCalculator.ConvertDistanceUnit(alt, GeoCalculator.DistanceUnits.Kilofeet, GeoCalculator.DistanceUnits.Degrees);
break;
case GeoCalculator.DistanceUnits.NauticalMiles:
this._alt = (float)GeoCalculator.ConvertDistanceUnit(alt, GeoCalculator.DistanceUnits.NauticalMiles, GeoCalculator.DistanceUnits.Degrees);
break;
case GeoCalculator.DistanceUnits.Degrees:
this._alt = alt;
break;
case GeoCalculator.DistanceUnits.Meters:
this._alt = (float)GeoCalculator.ConvertDistanceUnit(alt, GeoCalculator.DistanceUnits.Meters, GeoCalculator.DistanceUnits.Degrees);
break;
default:
throw new FormatException("Geopoint could not be constructed with the given Distance Units input");
}
}
public async Task <Response> MeasureDistance
(Location location1, Location location2)
{
Response measureResponse;
//check input coordinats is Double
if (IsDouble(location1.Lat, location1.Long) &&
IsDouble(location2.Lat, location2.Long))
{
double distance = GeoCalculator.
GetDistance(
double.Parse(location1.Lat),
double.Parse(location1.Long),
double.Parse(location2.Lat),
double.Parse(location2.Long), 1);
measureResponse = new MeasureResponse()
{
Location1 = location1,
Location2 = location2,
Distance = distance,
Code = StatusCodes.Status200OK,
Message = "Ok"
};
return(measureResponse);
}
return(new Response()
{
Code = StatusCodes.Status500InternalServerError,
Message = "Input Location Coordinates is Incorrect"
});
}
public async Task <List <PoiDto> > ListClosestPoisAsync(SearchPoiDto search)
{
if (search == null)
{
throw new ArgumentNullException(nameof(search));
}
IQueryable <Poi> query = DbContext.Pois;
//TODO: null-t nem engedni
IPoint location = null;
//order by distance
if (search.Longitude.HasValue && search.Latitude.HasValue)
{
location = LocationManager.GeometryFactory.CreatePoint(new GeoAPI.Geometries.Coordinate(search.Longitude.Value, search.Latitude.Value));
//TODO: valszeg ez nem marad szimplan query
query = query.OrderBy(p => p.Location.Distance(location));
}
var result = await query.Select(x => new { Poi = x, Distance = location != null ? x.Location.Distance(location) : 0 }).ToListAsync();
var pois = Mapper.Map <List <PoiDto> >(result.Select(r => r.Poi).ToList());
pois.ForEach(t => t.Distance = GeoCalculator.GetDistance(location.Y, location.X, t.Latitude, t.Longitude, 1, DistanceUnit.Kilometers));
return(pois);
}
public double CalcularDistancia()
{
int casasDecimais = 1;
return(GeoCalculator.GetDistance(Origem.Latitude, Origem.Longitude,
Destino.Latitude, Destino.Longitude, casasDecimais, DistanceUnit.Miles));
}
public async Task <MeasureResponse> MeasureDistance
(Location location1, Location location2)
{
MeasureResponse measureResponse;
if (IsDouble(location1.Latitude, location1.Longitude) &&
IsDouble(location2.Latitude, location2.Longitude))
{
double distance = GeoCalculator.
GetDistance(
double.Parse(location1.Latitude),
double.Parse(location1.Longitude),
double.Parse(location2.Latitude),
double.Parse(location2.Longitude), 1);
measureResponse = new MeasureResponse()
{
Location1 = location1,
Location2 = location2,
Distance = distance,
Code = StatusCodes.Status200OK,
Message = "Ok"
};
return(measureResponse);
}
else
{
}
}
public async Task <ObjectResult> GetSuggestions()
{
string userId = sessionService.GetCurrentUserId();
ApplicationUser user = await userRepository.GetUserAccount(userId);
CoordinateBoundaries boundaries = new CoordinateBoundaries(user.Lat, user.Lon, user.MatchRadius, DistanceUnit.Kilometers);
IEnumerable <ApplicationUser> matchesInRadius = await suggestionsRepository.GetUsersInMatchRadius(boundaries.MinLatitude, boundaries.MaxLatitude, boundaries.MinLongitude, boundaries.MaxLongitude);
IEnumerable <string> previouslyRespondedSuggestionsIds = suggestionsRepository.GetPreviousSuggestions(userId);
IEnumerable <ReturnedUser> suggestedUsers = matchesInRadius.Select(x => new ReturnedUser
{
Id = x.Id,
Username = x.UserName,
Name = x.Name != null && x.Name.Length != 0 ? x.Name : x.UserName,
Picture = x.Picture,
Bio = x.Bio,
LookingFor = x.LookingFor,
Genres = x.Genres.Select(ug => ug.Genre.Name).ToArray(),
Venues = x.Venues.Select(uv => uv.Venue.Name).ToArray(),
Distance = GeoCalculator.GetDistance(user.Lat, user.Lon, x.Lat, x.Lon)
}).ToList()
.Where(x => x.Id != user.Id)
.Where(x => !previouslyRespondedSuggestionsIds.Contains(x.Id))
.Where(x => x.Distance <= user.MatchRadius)
.OrderBy(x => x.Distance);
foreach (ReturnedUser u in suggestedUsers)
{
u.Role = await userRepository.GetAcountRole(u.Id);
}
return(Ok(suggestedUsers));
}
private IEnumerable <ResultModel> GetResults(Coordinate originCoordinate, double radius, DistanceUnit distanceUnit)
{
// Get the boundaries (min and max) latitude and longitude values. This forms a "square" around the origin coordinate
// with each leg of the square exactly "X" miles from the origin, where X is the selected radius.
var boundaries = new CoordinateBoundaries(originCoordinate.Latitude, originCoordinate.Longitude, radius, distanceUnit);
// Select from all of the locations
return(Locations
// Where the location's latitude is between the min and max latitude boundaries
.Where(x => x.Latitude >= boundaries.MinLatitude && x.Latitude <= boundaries.MaxLatitude)
// And where the location's longitude is between the min and max longitude boundaries
.Where(x => x.Longitude >= boundaries.MinLongitude && x.Longitude <= boundaries.MaxLongitude)
// Populate an instance of the Result class with the desired data, including distance/direction calculation
.Select(result => new ResultModel
{
Name = result.Name,
Distance = GeoCalculator.GetDistance(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude, distanceUnit: distanceUnit),
Direction = GeoCalculator.GetDirection(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude)
})
// Filter by distance. This is necessary because a radius is a circle, yet we've defined a square around the origin coordinate.
// This filter removes any extraneous results that would appear in the square's "corners" (imagine placing a circle inside a square of the
// same size for visualization).
.Where(x => x.Distance <= radius)
// Sort by distance
.OrderBy(x => x.Distance));
}
public double DistanceTo(IataPoint destinationPoint)
{
var origin = new Coordinate(this.Location.Latitude, this.Location.Longitude);
var destination = new Coordinate(destinationPoint.Location.Latitude, destinationPoint.Location.Longitude);
return(GeoCalculator.GetDistance(origin, destination));
}
public void GetScalebarDistanceParams(out float d1, out float d2, out float d, out int number, out string unit)
{
d1 = (float)GeoCalculator.PixelsToMetes(minSize, canvas.scaleFactor, map.zoom);
d2 = (float)GeoCalculator.PixelsToMetes(maxSize, canvas.scaleFactor, map.zoom);
d = GetNumberAndUnit(d2, out number, out unit);
}
/// <summary>
/// Uses https://www.nuget.org/packages/Geolocation/
/// </summary>
public void Test()
{
var landsEndLocation = new Coordinate(50.0775475, -5.6352355);
var johnOGroatsLocation = new Coordinate(58.6366688, -3.0827024);
double distance = GeoCalculator.GetDistance(landsEndLocation, johnOGroatsLocation, 1, DistanceUnit.Kilometers);
}
private void UpdateMapBounds()
{
// Convert view bounds (in Unity units) to tile ids
int northId = anchor.Y - Mathf.CeilToInt((viewBounds.yMax - anchorOffsetInUnits.y) * unitsToTiles + verticalBuffer);
int southId = anchor.Y - Mathf.FloorToInt((viewBounds.yMin - anchorOffsetInUnits.y) * unitsToTiles - verticalBuffer);
int westId = anchor.X + Mathf.FloorToInt((viewBounds.xMin - anchorOffsetInUnits.x) * unitsToTiles - horizontalBuffer);
int eastId = anchor.X + Mathf.CeilToInt((viewBounds.xMax - anchorOffsetInUnits.x) * unitsToTiles + horizontalBuffer);
mapTileBounds.Set(northId, southId, westId, eastId);
// Update coordinate bounds (in degrees)
var offsetMeters = GeoCalculator.RelativePixelsToMeters(viewBounds.xMax * unitsToPixels, viewBounds.yMax * unitsToPixels, zoomLevel);
var LonLat = GeoCalculator.MetersToLonLat(currentMeters + offsetMeters);
mapCoordBounds.east = LonLat.Longitude;
mapCoordBounds.north = LonLat.Latitude;
offsetMeters = GeoCalculator.RelativePixelsToMeters(viewBounds.xMin * unitsToPixels, viewBounds.yMin * unitsToPixels, zoomLevel);
LonLat = GeoCalculator.MetersToLonLat(currentMeters + offsetMeters);
mapCoordBounds.west = LonLat.Longitude;
mapCoordBounds.south = LonLat.Latitude;
if (OnBoundsChange != null)
{
OnBoundsChange();
}
}
public ActionResult <IEnumerable <PacijentReadDTO> > GetAllPacijenti()
{
var pacijenti = _repository.GetAllPacijenti();
foreach (var pacijent in pacijenti)
{
var stanje = _stanjeRepo.GetLastStanjeByID(pacijent.Id);
var udaljenost = 0d;
var trenutnaLokacija = _lokacijaRepo.GetLastLokacijeByID(pacijent.Id);
if (trenutnaLokacija?.Id != null && trenutnaLokacija?.Id != 0)
{
var TL = new Coordinate(Convert.ToDouble(trenutnaLokacija.Lat), Convert.ToDouble(trenutnaLokacija.Long));
var SI = new Coordinate(Convert.ToDouble(pacijent.Lat), Convert.ToDouble(pacijent.Long));
udaljenost = GeoCalculator.GetDistance(TL, SI, 5) / 0.62137;
}
if (stanje?.Temperatura > 37)
{
pacijent.Stanje = "Visoka temp.";
}
else if (udaljenost > 1)
{
pacijent.Stanje = "Udaljen više od 1km";
}
else
{
pacijent.Stanje = "Ok";
}
}
return(Ok(_mapper.Map <IEnumerable <PacijentReadDTO> >(pacijenti)));
}
static void Main(string[] args)
{
var path = Environment.CurrentDirectory + "\\Taco_Bell-US-AL-Alabama.csv";
Logger.Info("Log initialized");
Logger.Info("Grabbing from path: " + path);
var lines = File.ReadAllLines(path);
if (lines.Length == 0)
{
Logger.Error("No locations to check. Must have at least one location.");
}
else if (lines.Length == 1)
{
Logger.Warn("Only one location provided. Must have two to perform a check");
}
var parser = new TacoParser();
Logger.Info(("Initialized our Parser"));
var locations = lines.Select(line => parser.Parse(line))
.OrderBy(loc => loc.Location.Longitude)
.ThenBy(loc => loc.Location.Latitude)
.ToArray();
ITrackable a = null;
ITrackable b = null;
double distance = 0;
foreach (var locA in locations)
{
var origin = new Coordinate
{
Latitude = locA.Location.Latitude,
Longitude = locA.Location.Longitude
};
foreach (var locB in locations)
{
var dest = new Coordinate
{
Latitude = locB.Location.Latitude,
Longitude = locB.Location.Longitude
};
var nDist = GeoCalculator.GetDistance(origin, dest);
if (nDist > distance)
{
distance = nDist;
a = locA;
b = locB;
}
}
}
Console.WriteLine($"The first Taco Bell location is {a.Name} and the furthest distance away {b.Name}, with a distance of {distance}");
Console.ReadLine();
}
private void UpdateProjectionValues()
{
if (grid.countY == 0)
{
return;
}
int count = grid.countY + 1;
if (projection == null || projection.width != count)
{
CreateProjectionBuffer(count);
}
double min = GeoCalculator.LatitudeToNormalizedMercator(grid.south);
double max = GeoCalculator.LatitudeToNormalizedMercator(grid.north);
double invLatRange = (1.0 / (grid.north - grid.south));
float[] lats = new float[count];
double projLatInterval = (max - min) / (count - 1);
for (int i = 0; i < count; i++)
{
double projLat = min + i * projLatInterval;
double lat = (2 * Math.Atan(Math.Exp(projLat * Math.PI)) - HalfPI) * Rad2Deg;
lats[i] = Mathf.Clamp01((float)(1 - (lat - grid.south) * invLatRange));
}
byte[] latBytes = new byte[lats.Length * 4];
Buffer.BlockCopy(lats, 0, latBytes, 0, latBytes.Length);
projection.LoadRawTextureData(latBytes);
projection.Apply();
}
public async Task <DroneDTO> DroneAtendePedido(Pedido pedido)
{
double latitudeSaidaDrone = -23.5880684;
double longitudeSaidaDrone = -46.6564195;
double distance = GeoCalculator.GetDistance(latitudeSaidaDrone, longitudeSaidaDrone, pedido.Latitude, pedido.Longitude, 1, DistanceUnit.Kilometers) * 2;
_droneService.GerenciarDrones();
var drones = await _droneService.GetDisponiveis();
var buscaDrone = drones.Where(d => d.PerformanceRestante >= distance && d.CapacidadeRestante >= pedido.Peso).FirstOrDefault();
if (buscaDrone == null)
{
return(null);
}
buscaDrone.PerformanceRestante -= (float)distance;
buscaDrone.CapacidadeRestante -= pedido.Peso;
buscaDrone.Situacao = (int)EStatusDrone.AGUARDANDO;
if ((buscaDrone.CapacidadeRestante <= (buscaDrone.Capacidade * 0.5)) || (buscaDrone.PerformanceRestante <= (buscaDrone.Perfomance * 0.5)))
{
buscaDrone.Situacao = (int)EStatusDrone.OCUPADO;
}
_droneService.Update(buscaDrone);
return(new DroneDTO(buscaDrone, distance));
}
public IActionResult Index(string searchString, double lat, double lng, float radius)
{
IEnumerable <Event> events = new List <Event>();
try
{
events = _eventRepository.GetEvents().Result;
}
catch (TimeoutException)
{
return(RedirectToAction("Error"));
}
if (!String.IsNullOrEmpty(searchString))
{
events = events.Where(e => e.Name.ToLower().Contains(searchString.ToLower()) || e.Description.ToLower().Contains(searchString.ToLower()));
}
foreach (var item in events)
{
item.Image = _imageRepository.GetImage(item.Id);
item.EventStatus = _eventRepository.CheckStatus(item);
}
if (!Double.IsNaN(lat) && !Double.IsNaN(lng) && lat != 0 && lng != 0)
{
events = events.Where(e => GeoCalculator.GetDistance(e.Lat, e.Long, lat, lng, 1, DistanceUnit.Kilometers) <= radius);
}
return(View(events.ToList()));
}
public static IAirportDistanceMap FromAirports(List <AlgorithmAirport> airports)
{
if (airports == null || !airports.Any())
{
throw new ArgumentException(nameof(airports));
}
var len = airports.Count();
var result = new AirportDistanceMap()
{
_map = new Dictionary <AlgorithmAirport, Dictionary <AlgorithmAirport, double> >(len),
};
foreach (var fromAirport in airports)
{
result._map[fromAirport] = new Dictionary <AlgorithmAirport, double>(len);
foreach (var destinationAirport in airports)
{
result._map[fromAirport][destinationAirport] = GeoCalculator.GetDistance(fromAirport.Coordinate, destinationAirport.Coordinate, distanceUnit: DistanceUnit.Kilometers);
}
}
return(result);
}
private void UpdateCenter(double lon, double lat)
{
// Wrap coordinate
while (lon < GeoCalculator.MinLongitude)
{
lon += 2 * GeoCalculator.MaxLongitude;
}
while (lon > GeoCalculator.MaxLongitude)
{
lon += 2 * GeoCalculator.MinLongitude;
}
while (lat < GeoCalculator.MinLatitude)
{
lat += 2 * GeoCalculator.MaxLatitude;
}
while (lat > GeoCalculator.MaxLatitude)
{
lat += 2 * GeoCalculator.MinLatitude;
}
// Update lon/lat location
longitude = lon;
latitude = lat;
currentMeters = GeoCalculator.LonLatToMeters(longitude, latitude);
}
public override void UpdateContent()
{
bounds = map.MapCoordBounds;
if (degrees)
{
UpdateProjectionValues();
}
else
{
// Convert Lon/Lat to meters
var meters = GeoCalculator.LonLatToMeters(bounds.east, bounds.north);
bounds.east = meters.x;
bounds.north = meters.y;
meters = GeoCalculator.LonLatToMeters(bounds.west, bounds.south);
bounds.west = meters.x;
bounds.south = meters.y;
}
var invBoundsX = 1.0 / (bounds.east - bounds.west);
var invBoundsY = 1.0 / (bounds.north - bounds.south);
var interval = new Vector4((float)(intervalX * invBoundsX), (float)(intervalY * invBoundsY), 0, 0);
var offsetX = (float)(((0.5f * (bounds.east + bounds.west)) % intervalX) * invBoundsX);
var offsetY = (float)(((0.5f * (bounds.north + bounds.south)) % intervalY) * invBoundsY);
var offset = new Vector4(offsetX, offsetY, 0, 0);
if (degrees)
{
offset.y = -offset.y;
}
material.SetVector("Interval", interval);
material.SetVector("Offset", offset);
}
public static GeolocationPlace[] GetUserCurrentLocations(IGeolocationTarget[] users, string userId, string deviceName)
{
var user = users.FirstOrDefault(x => x.Id.Equals(userId));
if (user == null)
{
return new GeolocationPlace[] { GeolocationPlace.Empty }
}
;
var userLocations = GetNonGpsLocations(user, deviceName);
if (!userLocations.Any())
{
return new GeolocationPlace[] { GeolocationPlace.Other }
}
;
var userLastLocation = userLocations.Last();
var places = PlacesManager.Current.Places.OrderBy(x => x.MetersRadious).ToArray();
var targetPlaces = places.Where(x =>
GeoCalculator.GetDistance(
x.Location.Latitude, x.Location.Longtitude,
userLastLocation.Geolocation.Latitude, userLastLocation.Geolocation.Longtitude,
1,
DistanceUnit.Meters) <= x.MetersRadious)
.OrderBy(x => x.MetersRadious)
.ToArray();
return(targetPlaces.Any() ? targetPlaces : new GeolocationPlace[] { GeolocationPlace.Other });
}
public IEnumerable <Post> GetPostsInRange([FromBody] Location model)
{
if (ModelState.IsValid)
{
var userId = HttpContext.User.GetUserId();
var user = _context.User.FirstOrDefault(x => x.Id == userId);
//CoordinateBoundaries boundaries = new CoordinateBoundaries(model.Latitude, model.Longitude, user.SearchRange/1.6);
//var posts = _context.Post.AsQueryable();
//var result = posts.Where(
// x => x.Latitude >= boundaries.MinLatitude && x.Latitude <= boundaries.MaxLatitude)
// .Where(x => x.Longitude >= boundaries.MinLongitude && x.Longitude <= boundaries.MaxLongitude);
//range - dystans w kilometrach
//GeoCalculation.GetDistance(...) - zwraca dystans w milach => 1 mila = 1.6 km
var posts = (from p in _context.Post.Include(p => p.PostTags)
let range = user.SearchRange / 1000
where
range >=
GeoCalculator.GetDistance(model.Latitude, model.Longitude, p.Latitude, p.Longitude, 5) / 1.6
orderby p.AddDate descending
select p
).ToList();
for (int i = 0; i < posts.Count; i++)
{
posts[i].user = _context.User.FirstOrDefault(x => x.Id == posts[i]._UserId);
}
//range - dystans w kilometrach
//GeoCalculation.GetDistance(...) - zwraca dystans w milach => 1 mila = 1.6 km
//var result = _context.Post.Include(x => x.user).Where(x => x.user.SearchRange / 100 >= GeoCalculator.GetDistance(model.Latitude, model.Longitude, x.Latitude, x.Longitude, 5) / 1.6);
return(posts);
}
return(null);
}
public async Task <ObjectResult> GetMatches()
{
string userId = sessionService.GetCurrentUserId();
ApplicationUser currentUser = await userRepository.GetUserAccount(userId);
IEnumerable <string> matchIds = matchRepository.GetMatches(userId);
List <ReturnedUser> matches = new List <ReturnedUser>();
foreach (string id in matchIds)
{
ApplicationUser match = await userRepository.GetUserAccount(id);
ReturnedUser matchResponse = new ReturnedUser
{
Id = match.Id,
Username = match.UserName,
Name = match.Name != null && match.Name.Length != 0 ? match.Name : match.UserName,
Picture = match.Picture,
Bio = match.Bio,
LookingFor = match.LookingFor,
Genres = match.Genres.Select(ug => ug.Genre.Name).ToArray(),
Venues = match.Venues.Select(uv => uv.Venue.Name).ToArray(),
Distance = GeoCalculator.GetDistance(currentUser.Lat, currentUser.Lon, match.Lat, match.Lon),
Role = await userRepository.GetAcountRole(match.Id)
};
matches.Add(matchResponse);
}
return(Ok(matches));
}
public static Expression <Func <T, double> > CalculateDistanceFrom <T>(double originLatitude, double originLongitude, string latitudePropertyName, string longitudePropertyName, DistanceUnit distanceUnit)
{
var earthsRadiusConstantExpression = Expression.Constant(GeoCalculator.GetRadius(distanceUnit));
var inputExpression = Expression.Parameter(typeof(T), "x");
var originLatitudeExpression = Expression.Constant(originLatitude);
var originLongitudeExpression = Expression.Constant(originLongitude);
var destinationLatitudeExpression = Expression.Convert(Expression.Property(inputExpression, latitudePropertyName), typeof(double));
var destinationLongitudeExpression = Expression.Convert(Expression.Property(inputExpression, longitudePropertyName), typeof(double));
if (originLatitude < -90 || originLatitude > 90 || originLongitude < -180 || originLongitude > 180)
{
return(Expression.Lambda <Func <T, double> >(Expression.Constant(-1.0), inputExpression));
}
return(Expression.Lambda <Func <T, double> >(
Expression.Multiply(
earthsRadiusConstantExpression,
Expression.Multiply(
Expression.Constant(2.0),
Expression.Call(_asin,
// MIN isn't supported in SQL
// Tested all (4B+) combinations of valid Lat/Long and calculation was never greater than 1
//Expression.Call(_min,
// Expression.Constant(1.0),
Expression.Call(_sqrt,
Expression.Add(
Expression.Call(_pow,
Expression.Call(_sin,
Expression.Divide(
originLatitudeExpression.DiffRadiansExpression(destinationLatitudeExpression),
Expression.Constant(2.0)
)
),
Expression.Constant(2.0)
),
Expression.Multiply(
Expression.Call(_cos, originLatitudeExpression.ToRadiansExpression()),
Expression.Multiply(
Expression.Call(_cos, destinationLatitudeExpression.ToRadiansExpression()),
Expression.Call(_pow,
Expression.Call(_sin,
Expression.Divide(
originLongitudeExpression.DiffRadiansExpression(destinationLongitudeExpression),
Expression.Constant(2.0)
)
),
Expression.Constant(2.0)
)
)
)
)
)
//)
)
)
),
inputExpression));
}
/// <summary>
/// Method to get the distance in miles between to sets of coordinates
/// </summary>
/// <param name="lat1"> Double of the first locations latitude </param>
/// <param name="long1"> Double of the first locations longitude </param>
/// <param name="lat2"> Double of the second locations latitude </param>
/// <param name="long2"> Double of the second locations longitude </param>
/// <returns> Double representing the distance between the 2 given locations in miles </returns>
public static double GetDistanceBetweenTwoLocations(double lat1, double long1, double lat2, double long2)
{
Coordinate location1 = new Coordinate(lat1, long1);
Coordinate location2 = new Coordinate(lat2, long2);
double distance = GeoCalculator.GetDistance(location1, location2, 1);
return(distance);
}
private static Coordinate CalcActiveSiteCenter()
{
var bounds = GetActiveSiteAreaBounds();
var max = GeoCalculator.LonLatToMeters(bounds.east, bounds.north);
var min = GeoCalculator.LonLatToMeters(bounds.west, bounds.south);
var center = GeoCalculator.MetersToLonLat((min.x + max.x) * 0.5, (min.y + max.y) * 0.5);
return(center);
}
public void GetBearingThrowsArgumentExceptionWithInvalidOriginCoordinates()
{
Coordinate origin = Constants.Coordinates.LatitudeBelowMinimum;
Coordinate destination = Constants.Coordinates.ValidCoordinate;
var ex = Assert.Throws <ArgumentException>(() => GeoCalculator.GetBearing(origin.Latitude, origin.Longitude, destination.Latitude, destination.Longitude));
Assert.AreEqual("Invalid origin coordinates supplied.", ex.Message);
}
public Task <MeasureResponse> MeasureDistance
(Location location1, Location location2)
{
if (IsDouble(location1.Latitude, location1.Longitude) &&
IsDouble(location2.Latitude, location2.Longitude))
{
double distance = GeoCalculator.GetDistance(34.0675918, -118.3977091, 34.076234, -118.395314, 1);
}
}
public async Task <double> Calculate(string from, string to)
{
var fromAirport = await airportClient.GetAirportData(from);
var toAirport = await airportClient.GetAirportData(to);
return(GeoCalculator.GetDistance(fromAirport.location.lat, fromAirport.location.lon,
toAirport.location.lat, toAirport.location.lon, 1));
}
public void GetDistanceThrowsArgumentExceptionWithInvalidDestinationCoordinates()
{
Coordinate origin = Constants.Coordinates.ValidCoordinate;
Coordinate destination = Constants.Coordinates.LatitudeBelowMinimum;
var ex = Assert.Throws <ArgumentException>(() => GeoCalculator.GetDistance(origin.Latitude, origin.Longitude, destination.Latitude, destination.Longitude, 1));
Assert.AreEqual(ex.Message, "Invalid destination coordinates supplied.");
}
private double GetDistanceBetweenPersons(Person person1, Person person2)
{
var person1Location = new Coordinate(person1.Address.Geo.Lat, person1.Address.Geo.Lng);
var person2Location = new Coordinate(person2.Address.Geo.Lat, person2.Address.Geo.Lng);
var distance = GeoCalculator.GetDistance(person1Location, person2Location);
return(distance);
}
