protected void btnSearch_Click(object sender, EventArgs e) { double radius = Convert.ToDouble(Radius.SelectedValue); // These coordinates would normally be retrieved from a geocoding API such as Google's or Bing's. // See https://github.com/scottschluer/Geocoder for an easy to use Geocoder API for Google. Coordinate originCoordinate = new Coordinate { Latitude = 34.076234, Longitude = -118.395314 }; // 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. CoordinateBoundaries boundaries = new CoordinateBoundaries(originCoordinate.Latitude, originCoordinate.Longitude, radius); // Select from all of the locations IEnumerable<Result> results = _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 Result { Name = result.Name, Distance = GeoCalculator.GetDistance(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude, 1), 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); gvLocations.DataSource = results; gvLocations.DataBind(); }
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 override Task <AssaultCommand> InPosition(Position position, ServerCallContext context) { var boundaries = new CoordinateBoundaries( position.Latitude, position.Longitude, 15.2, DistanceUnit.Kilometers); var unavailableBoundaries = new CoordinateBoundaries( position.Latitude, position.Longitude, 4.2, DistanceUnit.Kilometers); return(InPositionFaultPolicy.ExecuteAsync( () => Task.FromResult(new AssaultCommand { Position = new Position { Latitude = _faker.Random.Double(unavailableBoundaries.MaxLatitude, boundaries.MaxLatitude), Longitude = _faker.Random.Double(unavailableBoundaries.MaxLongitude, boundaries.MaxLongitude) }, DirectionDeviation = Math.Round(_faker.Random.Double(0, 360), 2) }))); }
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)); }
public void CalculateThrowsArgumentExceptionWithInvalidLatitudeProperty() { CoordinateBoundaries boundaries = new CoordinateBoundaries(); var ex = Assert.Throws<ArgumentException>(() => boundaries.Latitude = Constants.Coordinates.LatitudeBelowMinimum.Latitude); Assert.AreEqual(ex.Message, "Invalid coordinates supplied."); }
public void CalculateThrowsArgumentExceptionWithInvalidLongitudeProperty() { CoordinateBoundaries boundaries = new CoordinateBoundaries(); var ex = Assert.Throws <ArgumentException>(() => boundaries.Longitude = Constants.Coordinates.LongitudeBelowMinumum.Longitude); Assert.AreEqual(ex.Message, "Invalid coordinates supplied."); }
public List <ApplicationUser> GetBeneficiariesInRange(List <ApplicationUser> beneficiaries, ApplicationUser volunteer, int radiusInKm) { CoordinateBoundaries boundaries = new CoordinateBoundaries(volunteer.Latitude, volunteer.Longitude, radiusInKm, DistanceUnit.Meters); return(beneficiaries .Where(b => b.Latitude >= boundaries.MinLatitude && b.Latitude <= boundaries.MaxLatitude) .Where(b => b.Longitude >= boundaries.MinLongitude && b.Longitude <= boundaries.MaxLongitude) .AsEnumerable() .Where(b => IsInRange(volunteer, b)).ToList()); }
public IEnumerable <ApplicationUser> GetVolunteersInRange(IQueryable <ApplicationUser> volunteers, ApplicationUser beneficiary, int radiusInKm) { CoordinateBoundaries boundaries = new CoordinateBoundaries(beneficiary.Latitude, beneficiary.Longitude, radiusInKm, DistanceUnit.Kilometers); return(volunteers .Where(v => v.Latitude >= boundaries.MinLatitude && v.Latitude <= boundaries.MaxLatitude) .Where(v => v.Longitude >= boundaries.MinLongitude && v.Longitude <= boundaries.MaxLongitude) .AsEnumerable() .Where(v => IsInRange(v, beneficiary))); }
public void CalculateReturnsCorrectMaximumLongitude() { Coordinate origin = Constants.Coordinates.ValidCoordinate; int radius = 25; CoordinateBoundaries boundaries = new CoordinateBoundaries(origin.Latitude, origin.Longitude, radius); double expectedResult = -117.9603252732495; Assert.AreEqual(boundaries.MaxLongitude, expectedResult); }
public void CalculateReturnsCorrectMinimumLongitude() { Coordinate origin = Constants.Coordinates.ValidCoordinate; int radius = 25; CoordinateBoundaries boundaries = new CoordinateBoundaries(origin.Latitude, origin.Longitude, radius); double expectedResult = -118.83509292675051; Assert.AreEqual(boundaries.MinLongitude, expectedResult); }
public void CalculateWithCoordinateObjectReturnsCorrectMaximumLatitude() { Coordinate origin = Constants.Coordinates.ValidCoordinate; int radius = 25; CoordinateBoundaries boundaries = new CoordinateBoundaries(origin, radius); double expectedResult = 34.429910640579713; Assert.AreEqual(boundaries.MaxLatitude, expectedResult); }
public void CalculateWithCoordinateObjectReturnsCorrectMinimumLatitude() { Coordinate origin = Constants.Coordinates.ValidCoordinate; int radius = 25; CoordinateBoundaries boundaries = new CoordinateBoundaries(origin, radius); double expectedResult = 33.705272959420292; Assert.AreEqual(boundaries.MinLatitude, expectedResult); }
public void GetMaxLatitudeFromBearing_GivenCoordinates_expectCorrectLongitude() { Coordinate coordinate = new Coordinate(51.647611, 5.050500); CoordinateBoundaries boundaries = new CoordinateBoundaries(coordinate, 2.0, DistanceUnit.Meters); Assert.Equal(51.647629010716372, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 2)); Assert.Equal(51.647592989283623, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 91)); Assert.Equal(51.647629010716372, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 271)); Assert.Equal(51.647592989283623, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 269)); Assert.Equal(51.647592989283623, CoordinateExtensions.GetMaxLatitudeFromBearing(boundaries, 180)); }
public void CalculateReturnsCorrectMaximumLatitudeWithMetres() { // Arrange var origin = new Coordinate() { Latitude = 53.401556, Longitude = -2.978207 }; int distance = 100; // Act var boundaries = new CoordinateBoundaries(origin, distance, DistanceUnit.Metres); // Assert double expectedResult = 53.402456535818814; Assert.AreEqual(boundaries.MaxLatitude, expectedResult); }
private async Task <LocationResult> GetByLocation(Classes.Models.Location.Location location, int radius) { var boundaries = new CoordinateBoundaries(location.Lat, location.Lng, radius); var client = new HttpClient(); var query = await client.GetAsync($"https://query.displaypurposes.com/local/?bbox={boundaries.MinLongitude},{boundaries.MinLatitude},{boundaries.MaxLongitude},{boundaries.MaxLatitude}&zoom=10") .ConfigureAwait(false); var text = await query.Content.ReadAsStringAsync().ConfigureAwait(false); var results = SerializationHelper.DeserializeFromString <LocationResult>(text); return(results); }
public void GetMaxLongitudeFromBearing_GivenCoordinates_expectCorrectLongitude() { Coordinate coordinate = new Coordinate(51.647611, 5.050500); CoordinateBoundaries boundaries = new CoordinateBoundaries(coordinate, 2.0, DistanceUnit.Meters); Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 2)); Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 91)); Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 179)); Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 180)); Assert.Equal(5.0504709736944742, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 181)); Assert.Equal(5.0504709736944742, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 279)); Assert.Equal(5.0504709736944742, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 360)); Assert.Equal(5.0505290263055267, CoordinateExtensions.GetMaxLongitudeFromBearing(boundaries, 0)); }
private Location GetRandomLocation() { var boundaries = new CoordinateBoundaries(_center.Latitude, _center.Longitude, _radiusInMeters, DistanceUnit.Meters); double minLatitude = boundaries.MinLatitude; double maxLatitude = boundaries.MaxLatitude; double minLongitude = boundaries.MinLongitude; double maxLongitude = boundaries.MaxLongitude; var random = new Random(); var latitude = random.NextDouble() * (maxLatitude - minLatitude) + maxLatitude; var longitude = random.NextDouble() * (maxLongitude - minLongitude) + maxLongitude; return(new Location(longitude, latitude)); }
public async Task <Portal[]> GetPortals(double radius, Location location = default, CancellationToken cancellationToken = default) { location = location ?? myDefaultLocation; var boundaries = new CoordinateBoundaries(location.Latitude, location.Longitude, radius, DistanceUnit.Kilometers); var queryBuilder = new QueryBuilder { { "nelat", boundaries.MaxLatitude.ToString(CultureInfo.InvariantCulture) }, { "nelng", boundaries.MaxLongitude.ToString(CultureInfo.InvariantCulture) }, { "swlat", boundaries.MinLatitude.ToString(CultureInfo.InvariantCulture) }, { "swlng", boundaries.MinLongitude.ToString(CultureInfo.InvariantCulture) }, { "offset", 0.ToString() }, { "telegram", "" } }; return(await Execute("getPortals.php", queryBuilder, cancellationToken, "portalData")); }
private static List <Restaurant> SearchResturantsWithInSpecifiedMiles(RedisList <Restaurant> restaurants, int miles) { var boundaries = new CoordinateBoundaries(Latitude, Longitude, miles); var filteredRestaurants = new List <Restaurant>(); Parallel.ForEach(restaurants, (restaurant) => { if ((restaurant.ResturantGeo.Latitude >= boundaries.Latitude && restaurant.ResturantGeo.Latitude <= boundaries.Latitude) && (restaurant.ResturantGeo.Longitude >= boundaries.Longitude && restaurant.ResturantGeo.Longitude <= boundaries.Longitude)) { filteredRestaurants.Add(restaurant); } }); return(filteredRestaurants); }
public static Coordinate GetStepCoordinates(Coordinate from, Coordinate to, double distance) { var bearing = GeoCalculator.GetBearing(from, to); var angle = GetRelativeBearingToClosestDirection(bearing); var(latitudeFactor, longitudeFactor) = CorrectionFactors(angle, bearing); var boundaries = new CoordinateBoundaries(from, distance, DistanceUnit.Meters); var maxLongitude = GetMaxLongitudeFromBearing(boundaries, bearing); var maxLatitude = GetMaxLatitudeFromBearing(boundaries, bearing); var newLongitude = from.Longitude + (maxLongitude - from.Longitude) * longitudeFactor; var newLatitude = from.Latitude + (maxLatitude - from.Latitude) * latitudeFactor; return(new Coordinate(newLatitude, newLongitude)); }
/// <summary> /// Returns a <see cref="System.String"/> that represents this instance. /// </summary> /// <returns> /// A <see cref="System.String"/> that represents this instance. /// </returns> public override string ToString() { var retVal = string.Format("{0},{1},{2},{3}", MinLongitude, MinLatitude, MaxLongitude, MaxLatitude); if (UseCoordinates) { var boundaries = new CoordinateBoundaries(Latitude, Longitude, 0.25); // -122.75,36.8,-121.75,37.8 double minLatitude = boundaries.MinLatitude; double maxLatitude = boundaries.MaxLatitude; double minLongitude = boundaries.MinLongitude; double maxLongitude = boundaries.MaxLongitude; //var retVal = string.Format("{0},{1},{2},{3}", minLatitude, maxLongitude, maxLatitude, minLongitude); //var retVal = string.Format("{0},{1},{2},{3}", minLatitude, minLongitude, maxLatitude, maxLongitude); retVal = string.Format("{0},{1},{2},{3}", minLongitude, minLatitude, maxLongitude, maxLatitude); } return retVal; }
public async Task <ActionResult> GetBusinessforCustomer(BusinessForClientViewmodel businessForClientViewmodel) { var totalFeedBack = 0.0; var response = await context.Businesses.Include(bt => bt.businessType).Include(f => f.FeedBacks).Where(iv => iv.isVisible).AsNoTracking().ToListAsync(); for (int i = 0; i < response.Count; i++) { if (response[i].FeedBacks.Count > 0) { for (int j = 0; j < response[i].FeedBacks.Count; j++) { if (response[i].FeedBacks[j].OverallRating.HasValue) { totalFeedBack += response[i].FeedBacks[j].OverallRating.Value; } } response[i].OverallRating = totalFeedBack / double.Parse(response[i].FeedBacks.Count.ToString()); } } Coordinate origin = new Coordinate(businessForClientViewmodel.UserLatitude, businessForClientViewmodel.UserLongitude); CoordinateBoundaries boundaries = new CoordinateBoundaries(origin, 10); double minLatitude = boundaries.MinLatitude; double maxLatitude = boundaries.MaxLatitude; double minLongitude = boundaries.MinLongitude; double maxLongitude = boundaries.MaxLongitude; var results = response .Where(x => x.Latitude >= minLatitude && x.Latitude <= maxLatitude) .Where(x => x.Longitude >= minLongitude && x.Longitude <= maxLongitude) .Select(result => new { Store = result, Distance = GeoCalculator.GetDistance(origin.Latitude, origin.Longitude, result.Latitude, result.Longitude, 1), Direction = GeoCalculator.GetDirection(origin.Latitude, origin.Longitude, result.Latitude, result.Longitude) }) .Where(x => x.Distance <= 10) .OrderBy(x => x.Distance) .ToList(); response = results.Select(x => x.Store).ToList(); return(new OkObjectResult(response)); }
public override Task <RePositionCommand> RegisterUnit(RegisterArtilleryUnitRequest request, ServerCallContext context) { return(RegistrationLatency.ExecuteAsync(() => { var boundaries = new CoordinateBoundaries( request.Position.Latitude, request.Position.Longitude, 60, DistanceUnit.Kilometers); return Task.FromResult(new RePositionCommand { Position = new Position { Latitude = _faker.Random.Double(boundaries.MinLatitude, boundaries.MaxLatitude), Longitude = _faker.Random.Double(boundaries.MinLongitude, boundaries.MaxLongitude) }, MainFiringDirection = Math.Round(_faker.Random.Double(0, 360), 2) }); })); }
public IEnumerable <Book> SearchBooks(string regexString, List <CategoryOfBook> categoriesOfBook, double longitude, double latitude, double radius) { CoordinateBoundaries boundaries = new CoordinateBoundaries(latitude, longitude, radius, DistanceUnit.Kilometers); Regex regex; if (regexString == "") { regex = new Regex("^.*$"); } else { regex = new Regex($"^.*{regexString}.*$", RegexOptions.IgnoreCase); } return(_context.Books .Where(x => x.Latitude >= boundaries.MinLatitude && x.Latitude <= boundaries.MaxLatitude) .Where(x => x.Longitude >= boundaries.MinLongitude && x.Longitude <= boundaries.MaxLongitude) .Where(x => categoriesOfBook.Contains(x.Category)) .Include(p => p.Owner) .ToList() .FindAll(x => regex.IsMatch(x.Title))); }
protected void btnSearch_Click(object sender, EventArgs e) { double radius = Convert.ToDouble(Radius.SelectedValue); // These coordinates would normally be retrieved from a geocoding API such as Google's or Bing's. // See https://github.com/scottschluer/Geocoder for an easy to use Geocoder API for Google. Coordinate originCoordinate = new Coordinate { Latitude = 34.076234, Longitude = -118.395314 }; // 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. CoordinateBoundaries boundaries = new CoordinateBoundaries(originCoordinate.Latitude, originCoordinate.Longitude, radius); // Select from all of the locations IEnumerable <Result> results = _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 Result { Name = result.Name, Distance = GeoCalculator.GetDistance(originCoordinate.Latitude, originCoordinate.Longitude, result.Latitude, result.Longitude, 1), 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); gvLocations.DataSource = results; gvLocations.DataBind(); }
public static double GetMaxLongitudeFromBearing(CoordinateBoundaries boundary, double bearing) { return(bearing <= 180 ? boundary.MaxLongitude : boundary.MinLongitude); }
public static double GetMaxLatitudeFromBearing(CoordinateBoundaries boundary, double bearing) { return(bearing >= 90 && bearing < 270 ? boundary.MinLatitude : boundary.MaxLatitude); }
public async Task Assault( double targetLatitude, double targetLongitude, double directionDeviation, [Option(ShortName = "t")] TimeoutPolicyKey timeoutPolicyKey = TimeoutPolicyKey.NoTimeout, [Option(ShortName = "c")] TimeoutPolicyKey correctionTimeoutPolicyKey = TimeoutPolicyKey.NoTimeout) { var(horizontal, vertical) = GetAngles(targetLatitude, targetLongitude, directionDeviation); await _battery.Aim(horizontal, vertical, timeoutPolicyKey); await _battery.Fire(40, timeoutPolicyKey); var correctionTimeoutPolicy = _policyRegistry.Get <IAsyncPolicy>(correctionTimeoutPolicyKey.ToString()); var correctionFallbackPolicy = Policy .Handle <RpcException>() .Or <TimeoutRejectedException>() .FallbackAsync( async token => { var coordBoundaries = new CoordinateBoundaries(_battery.Latitude, _battery.Longitude, 2, DistanceUnit.Kilometers); _battery.RePosition( _faker.Random.Double(coordBoundaries.MinLatitude, coordBoundaries.MaxLatitude), _faker.Random.Double(coordBoundaries.MinLongitude, coordBoundaries.MaxLongitude) ); var assaultCommand = await _client.InPositionAsync(new Position { Latitude = _battery.Latitude, Longitude = _battery.Longitude }, deadline: DateTime.UtcNow.AddMilliseconds(1000)); _console.Out.WriteLine( $"Assault command received. Target: lat: {assaultCommand.Position.Latitude}; lon:{assaultCommand.Position.Longitude}" + $" direction: {assaultCommand.DirectionDeviation};"); }, async exception => { _console.Out.WriteLine($"Could not get correction, falling back to new position. Exception: {exception.Message}"); await Task.CompletedTask; }); var lastResortPolicy = Policy .Handle <RpcException>() .Or <TimeoutRejectedException>() .FallbackAsync(token => _battery.Disengage()); var policyWrap = Policy.WrapAsync(lastResortPolicy, correctionFallbackPolicy, correctionTimeoutPolicy); await policyWrap.ExecuteAsync(async token => { var correction = await _client.GetCorrectionAsync( new Position { Latitude = _battery.Latitude, Longitude = _battery.Longitude }, cancellationToken: token); token.ThrowIfCancellationRequested(); _console.Out.WriteLine( $"Assault command correction received. Target: lat: {correction.Position.Latitude}; lon:{correction.Position.Longitude}" + $" direction: {correction.DirectionDeviation};"); }, CancellationToken.None); }