def destination(self, point, bearing, distance=None): # pylint: disable=W0621 """ TODO docs. """ point = Point(point) lat1 = units.radians(degrees=point.latitude) lng1 = units.radians(degrees=point.longitude) bearing = units.radians(degrees=bearing) if distance is None: distance = self if isinstance(distance, Distance): distance = distance.kilometers d_div_r = float(distance) / self.RADIUS lat2 = asin( sin(lat1) * cos(d_div_r) + cos(lat1) * sin(d_div_r) * cos(bearing) ) lng2 = lng1 + atan2( sin(bearing) * sin(d_div_r) * cos(lat1), cos(d_div_r) - sin(lat1) * sin(lat2) ) return Point(units.degrees(radians=lat2), units.degrees(radians=lng2))
def parse_degrees(cls, degrees, arcminutes, arcseconds, direction=None): """ Convert degrees, minutes, seconds and direction (N, S, E, W) to a single degrees number. :rtype: float """ degrees = float(degrees) negative = degrees < 0 arcminutes = float(arcminutes) arcseconds = float(arcseconds) if arcminutes or arcseconds: more = units.degrees(arcminutes=arcminutes, arcseconds=arcseconds) if negative: degrees -= more else: degrees += more if direction in [None, 'N', 'E']: return degrees elif direction in ['S', 'W']: return -degrees else: raise ValueError("Invalid direction! Should be one of [NSEW].")
def near(self, latitude=None, longitude=None, distance_range=10): queryset = super(LocationManager, self).get_queryset() if not (latitude and longitude and distance_range): return queryset.none() latitude = float(latitude) longitude = float(longitude) distance_range = float(distance_range) rough_distance = units.degrees(arcminutes=units.nautical(kilometers=distance_range)) * 2 queryset = queryset.filter( latitude__range=( latitude - rough_distance, latitude + rough_distance ), longitude__range=( longitude - rough_distance, longitude + rough_distance ) ) locations = [] for location in queryset: if location.latitude and location.longitude: exact_distance = distance.distance( (latitude, longitude), (location.latitude, location.longitude) ).kilometers if exact_distance <= distance_range: locations.append(location) queryset = queryset.filter(id__in=[l.id for l in locations]) return queryset
def near(self, latitude=None, longitude=None, distance_range=None, skip_box_approximation=False): """ @param float latitude @param float longitude @param float distance_range in kilometers | Distance instance """ query_set = super(BaseLocationManager, self).get_query_set() if not (latitude and longitude and distance_range): return query_set.none() if not skip_box_approximation: lat, lon, dis = self._format_params(latitude, longitude, distance_range) # approximate the area where to search for places rough_distance = units.degrees(arcminutes=units.nautical(kilometers=dis)) * 2 query_set = query_set.filter( latitude__range=( lat - rough_distance, lat + rough_distance ), longitude__range=( lon - rough_distance, lon + rough_distance ) ) return query_set
def near(self, latitude=None, longitude=None, distance_range=None, skip_box_approximation=False): """ @param float latitude @param float longitude @param float distance_range in kilometers | Distance instance """ query_set = super(BaseLocationManager, self).get_query_set() if not (latitude and longitude and distance_range): return query_set.none() if not skip_box_approximation: lat, lon, dis = self._format_params(latitude, longitude, distance_range) # approximate the area where to search for places rough_distance = units.degrees(arcminutes=units.nautical( kilometers=dis)) * 2 query_set = query_set.filter( latitude__range=(lat - rough_distance, lat + rough_distance), longitude__range=(lon - rough_distance, lon + rough_distance)) return query_set
def nearby(self, latitude, longitude, distance_range=5, ids=None, exclude_ids=None): if latitude is None or longitude is None: return [] queryset = self.get_queryset().filter(is_registered=True, is_visible=True) if ids is not None: queryset = queryset.filter(id__in=ids) if exclude_ids is not None: queryset = queryset.exclude(id__in=exclude_ids) rough_distance = units.degrees(arcminutes=units.nautical( kilometers=distance_range)) * 2 latitude, longitude = float(latitude), float(longitude) queryset = queryset.filter( clatitude__range=(latitude - rough_distance, latitude + rough_distance), clongitude__range=(longitude - rough_distance, longitude + rough_distance)) result = [] for customer in queryset: exact_distance = distance.distance( (latitude, longitude), (customer.clatitude, customer.clongitude)).m result.append((customer, exact_distance)) result.sort(key=lambda x: x[1]) return result
def get_nearby_scouts(latitude, longitude, distance_range=50, queryset=None): from scouts.models import Scout if queryset is None: queryset = Scout.objects.all() rough_distance = units.degrees(arcminutes=units.nautical(kilometers=distance_range)) * 2 latitude, longitude = float(latitude), float(longitude) queryset = queryset.filter(work_address__latitude__range=(latitude - rough_distance, latitude + rough_distance), work_address__longitude__range=(longitude - rough_distance, longitude + rough_distance)) return queryset
def destination( point, bearing, distance): point = Point(point) lat1 = units.radians(degrees=point.latitude) lng1 = units.radians(degrees=point.longitude) d_div_r = float(distance) / 6372.795 lat2 = asin( sin(lat1) * cos(d_div_r) + cos(lat1) * sin(d_div_r) * cos(bearing) ) lng2 = lng1 + atan2( sin(bearing) * sin(d_div_r) * cos(lat1), cos(d_div_r) - sin(lat1) * sin(lat2) ) return Point(units.degrees(radians=lat2), units.degrees(radians=lng2))
def nearby(latitude, longitude, distance_range=5): queryset = House.objects.filter(visible=True) rough_distance = units.degrees(arcminutes=units.nautical( kilometers=distance_range)) * 2 latitude, longitude = float(latitude), float(longitude) queryset = queryset.filter( address__latitude__range=(latitude - rough_distance, latitude + rough_distance), address__longitude__range=(longitude - rough_distance, longitude + rough_distance)) return queryset
def near(self, location, distance=None): """ Returns a list of items in the :class:`QuerySet` which are within the given distance of the given location. Does NOT return a :class:`QuerySet`. Accepts either a :class:`Place` instance or a (lat, lon) tuple for location. Also accepts a Place instance with a ``nearby_distance`` attribute added (as returned from :func:`loci.utils.geolocate_request`); in this case, distance need not be explicitly passed. """ # figure out if we received an object or tuple and get the location try: (latitude, longitude) = location.location except AttributeError: (latitude, longitude) = location # make sure we have a valid location if not (latitude and longitude): return [] # get the passed distance or attached to Place if distance == None: try: distance = location.nearby_distance except AttributeError: raise ValueError('Distance must be attached or passed explicitly.') # prune down the set of places before checking precisely #deg_lat = Decimal(str(degrees(arcminutes=nautical(miles=distance)))) deg_lat = degrees(arcminutes=nautical(miles=distance)) lat_range = (latitude - deg_lat, latitude + deg_lat) long_range = (longitude - deg_lat * 2, longitude + deg_lat * 2) queryset = self.filter( latitude__range=lat_range, longitude__range=long_range ) locations = [] for location in queryset: if location.latitude and location.longitude: location.exact_distance = geopy.distance.distance( (latitude, longitude), (location.latitude, location.longitude) ) if location.exact_distance.miles <= distance: locations.append(location) return locations
def nearby_posts(cls, lat, long, dist): nearby_posts = [] d = distance.distance(miles=dist) rough_distance = Decimal(str(units.degrees(arcminutes=d.nm) * 2)) lat_lower = Decimal(lat) - rough_distance lat_upper = Decimal(lat) + rough_distance long_lower = Decimal(long) - rough_distance long_upper = Decimal(long) + rough_distance posts = db.session.query(Post).filter(Post.lat.between(lat_lower, lat_upper)) posts = posts.filter(Post.long.between(long_lower, long_upper)).order_by('id desc') for post in posts: exact_distance = distance.distance((post.lat, post.long), (lat, long)) if exact_distance.miles <= dist: nearby_posts.append(post) return nearby_posts
def nearby_posts(cls, lat, long, dist): nearby_posts = [] d = distance.distance(miles=dist) rough_distance = Decimal(str(units.degrees(arcminutes=d.nm) * 2)) lat_lower = Decimal(lat) - rough_distance lat_upper = Decimal(lat) + rough_distance long_lower = Decimal(long) - rough_distance long_upper = Decimal(long) + rough_distance posts = db.session.query(Post).filter( Post.lat.between(lat_lower, lat_upper)) posts = posts.filter(Post.long.between(long_lower, long_upper)).order_by('id desc') for post in posts: exact_distance = distance.distance((post.lat, post.long), (lat, long)) if exact_distance.miles <= dist: nearby_posts.append(post) return nearby_posts
def parse_degrees(cls, degrees, arcminutes, arcseconds, direction=None): degrees = float(degrees) negative = degrees < 0 arcminutes = float(arcminutes) arcseconds = float(arcseconds) if arcminutes or arcseconds: more = units.degrees(arcminutes=arcminutes, arcseconds=arcseconds) if negative: degrees -= more else: degrees += more if direction in [None, 'N', 'E']: return degrees elif direction in ['S', 'W']: return -degrees else: raise ValueError("Invalid direction! Should be one of [NSEW].")
def parse_degrees(cls, degrees, arcminutes, arcseconds, direction=None): negative = degrees < 0 or degrees.startswith('-') degrees = float(degrees or 0) arcminutes = float(arcminutes or 0) arcseconds = float(arcseconds or 0) if arcminutes or arcseconds: more = units.degrees(arcminutes=arcminutes, arcseconds=arcseconds) if negative: degrees -= more else: degrees += more if direction in [None, 'N', 'E']: return degrees elif direction in ['S', 'W']: return -degrees else: raise ValueError("Invalid direction! Should be one of [NSEW].")
def refreshtrips(request): latitude = request.POST.get('latitude') longitude = request.POST.get('longitude') request.session['latitude'] = latitude request.session['longitude'] = longitude lat = float(latitude) long = float(longitude) distance_range = float(ALLOWABLE_DIST) rough_distance = units.degrees(arcminutes=units.nautical( kilometers=distance_range)) * 2 all_trips = Trip.objects.filter( date__date=timezone.now() + timedelta(hours=9), status='ACT', meetup_pt__latitude__range=(lat - rough_distance, lat + rough_distance), meetup_pt__longitude__range=( long - rough_distance, long + rough_distance)).annotate( avail_passengers=MAX_PASSENGERS - Count('passenger')).filter( avail_passengers__lte=4, avail_passengers__gt=0).order_by('avail_passengers') nearby = [] for trip in all_trips: if trip.meetup_pt.latitude and trip.meetup_pt.longitude: exact_distance = distance.distance( (lat, long), (trip.meetup_pt.latitude, trip.meetup_pt.longitude)).kilometers if exact_distance <= distance_range: trip.distance = exact_distance nearby.append(trip) sorted(nearby, key=lambda m: m.distance) trip_cards = loader.render_to_string('discover/tripcards.html', {'trips': nearby}) output_data = {'trip_cards': trip_cards} return JsonResponse(output_data)
def near_by_lat_lng(self, latitude, longitude, proximity): """ Find service provider within latitude and longitude with distance :param latitude: latitude :param longitude: longitude :param proximity: distance :return: service-provider queryset """ rough_distance = units.degrees(arcminutes=units.nautical( kilometers=proximity)) * 2 queryset = self.get_queryset() \ .exclude(latitude=None) \ .exclude(longitude=None) \ .filter( latitude__range=(latitude - rough_distance, latitude + rough_distance), longitude__range=(longitude - rough_distance, longitude + rough_distance) ) return queryset.filter(id__in=[ obj.id for obj in queryset if proximity >= distance.distance(( latitude, longitude), (obj.latitude, obj.longitude)).kilometers ])
def parse_degrees(cls, degrees, arcminutes, arcseconds, direction=None): """ Parse degrees minutes seconds including direction (N, S, E, W) """ degrees = float(degrees) negative = degrees < 0 arcminutes = float(arcminutes) arcseconds = float(arcseconds) if arcminutes or arcseconds: more = units.degrees(arcminutes=arcminutes, arcseconds=arcseconds) if negative: degrees -= more else: degrees += more if direction in [None, 'N', 'E']: return degrees elif direction in ['S', 'W']: return -degrees else: raise ValueError("Invalid direction! Should be one of [NSEW].")
def organize(request): if request.POST.get('latitude') is not None and request.POST.get( 'longitude') is not None: latitude = request.POST.get('latitude') longitude = request.POST.get('longitude') request.session['latitude'] = latitude request.session['longitude'] = longitude lat = float(latitude) long = float(longitude) distance_range = float(ALLOWABLE_DIST) rough_distance = units.degrees(arcminutes=units.nautical( kilometers=distance_range)) * 2 all_meetup_pts = Meetup.objects.filter( latitude__range=(lat - rough_distance, lat + rough_distance), longitude__range=(long - rough_distance, long + rough_distance)) nearby = [] for meetup_pt in all_meetup_pts: if meetup_pt.latitude and meetup_pt.longitude: exact_distance = distance.distance( (lat, long), (meetup_pt.latitude, meetup_pt.longitude)).kilometers if exact_distance <= distance_range: meetup_pt.distance = exact_distance nearby.append(meetup_pt) sorted(nearby, key=lambda m: m.distance) context = {'nearby_meetups': nearby} return render(request, 'discover/organize.html', context) else: return HttpResponseRedirect(reverse('discover:index'))
def parse_degrees(cls, degrees, arcminutes, arcseconds, direction=None): """ Parse degrees minutes seconds including direction (N, S, E, W) """ degrees = float(degrees) negative = degrees < 0 arcminutes = float(arcminutes) arcseconds = float(arcseconds) if arcminutes or arcseconds: more = units.degrees(arcminutes=arcminutes, arcseconds=arcseconds) if negative: degrees -= more else: degrees += more if not direction: return degrees elif direction.upper() in ['N', 'E', 'NORTH', 'EAST']: return degrees elif direction.upper() in ['S', 'W', 'SOUTH', 'WEST']: return -degrees else: raise ValueError("Invalid direction! Should be one of [NSEW].")
def search(request): context = RequestContext(request) if request.method == 'POST': search_text = request.POST['search_text'] search_type = request.POST['type'] granted=Permission.objects.filter(permitted__exact=request.user) granted=[i.owner for i in granted] #Keyword Search Option if search_type == 'all': q1 = Bulletin.objects.filter( Q(title__icontains=search_text) | Q(text_description__icontains=search_text)) query = q1.order_by('date_created', 'title') # Title Search Option if search_type == 'title': # if text is contained within title q1 = Bulletin.objects.filter(title__icontains=search_text) # order by publication date, then headline query =q1.order_by('date_created', 'title') #Author Search Option if search_type == 'author': # gets author id based on search of username author = User.objects.get(username__exact=search_text) id = author.id # query db to find all bulletins with given id q1 = Bulletin.objects.filter(author_id__exact=id) # order by publication date, then headline query =q1.order_by('date_created', 'title') if search_type == 'date': # if text is contained within title q1 = Bulletin.objects.filter(date_created=search_text) # order by publication date, then headline query =q1.order_by('date_created', 'title') if search_type =='location': lat,long=location_lookup(search_text) rough_distance = units.degrees(arcminutes=units.nautical(miles=50)) q1=Bulletin.objects.filter(Q(lat__range=(lat-rough_distance,lat+rough_distance))|Q(long__range=(long-rough_distance,long+rough_distance))) query=q1.order_by('date_created','title') bulletins=[] for b in query: # if b.author in granted: bulletins.append(b) # # print string # print "bulletins" # print bulletins return render_to_response('search.html', {'bulletins':bulletins}, context) else: #The request is not a POST so it's probably a GET request return render_to_response('search.html', {}, context)
def destination(self, point, bearing, distance=None): # pylint: disable=W0621 """ TODO docs. """ point = Point(point) lat1 = units.radians(degrees=point.latitude) lng1 = units.radians(degrees=point.longitude) bearing = units.radians(degrees=bearing) if distance is None: distance = self if isinstance(distance, Distance): distance = distance.kilometers ellipsoid = self.ELLIPSOID if isinstance(ellipsoid, string_compare): ellipsoid = ELLIPSOIDS[ellipsoid] major, minor, f = ellipsoid tan_reduced1 = (1 - f) * tan(lat1) cos_reduced1 = 1 / sqrt(1 + tan_reduced1 ** 2) sin_reduced1 = tan_reduced1 * cos_reduced1 sin_bearing, cos_bearing = sin(bearing), cos(bearing) sigma1 = atan2(tan_reduced1, cos_bearing) sin_alpha = cos_reduced1 * sin_bearing cos_sq_alpha = 1 - sin_alpha ** 2 u_sq = cos_sq_alpha * (major ** 2 - minor ** 2) / minor ** 2 A = 1 + u_sq / 16384. * ( 4096 + u_sq * (-768 + u_sq * (320 - 175 * u_sq)) ) B = u_sq / 1024. * (256 + u_sq * (-128 + u_sq * (74 - 47 * u_sq))) sigma = distance / (minor * A) sigma_prime = 2 * pi while abs(sigma - sigma_prime) > 10e-12: cos2_sigma_m = cos(2 * sigma1 + sigma) sin_sigma, cos_sigma = sin(sigma), cos(sigma) delta_sigma = B * sin_sigma * ( cos2_sigma_m + B / 4. * ( cos_sigma * ( -1 + 2 * cos2_sigma_m ** 2 ) - B / 6. * cos2_sigma_m * ( -3 + 4 * sin_sigma ** 2 ) * ( -3 + 4 * cos2_sigma_m ** 2 ) ) ) sigma_prime = sigma sigma = distance / (minor * A) + delta_sigma sin_sigma, cos_sigma = sin(sigma), cos(sigma) lat2 = atan2( sin_reduced1 * cos_sigma + cos_reduced1 * sin_sigma * cos_bearing, (1 - f) * sqrt( sin_alpha ** 2 + ( sin_reduced1 * sin_sigma - cos_reduced1 * cos_sigma * cos_bearing ) ** 2 ) ) lambda_lng = atan2( sin_sigma * sin_bearing, cos_reduced1 * cos_sigma - sin_reduced1 * sin_sigma * cos_bearing ) C = f / 16. * cos_sq_alpha * (4 + f * (4 - 3 * cos_sq_alpha)) delta_lng = ( lambda_lng - (1 - C) * f * sin_alpha * ( sigma + C * sin_sigma * ( cos2_sigma_m + C * cos_sigma * ( -1 + 2 * cos2_sigma_m ** 2 ) ) ) ) lng2 = lng1 + delta_lng return Point(units.degrees(radians=lat2), units.degrees(radians=lng2))
def createTrip(request): organizer = request.POST.get('organizer') selected_meetup = request.POST.get('choice') organizer = organizer.strip(' ') latitude = request.session['latitude'] longitude = request.session['longitude'] lat = float(latitude) long = float(longitude) if len(organizer) == 0: distance_range = float(ALLOWABLE_DIST) rough_distance = units.degrees(arcminutes=units.nautical( kilometers=distance_range)) * 2 all_meetup_pts = Meetup.objects.filter( latitude__range=(lat - rough_distance, lat + rough_distance), longitude__range=(long - rough_distance, long + rough_distance)) nearby = [] for meetup_pt in all_meetup_pts: if meetup_pt.latitude and meetup_pt.longitude: exact_distance = distance.distance( (lat, long), (meetup_pt.latitude, meetup_pt.longitude)).kilometers if exact_distance <= distance_range: meetup_pt.distance = exact_distance nearby.append(meetup_pt) sorted(nearby, key=lambda m: m.distance) context = { 'nearby_meetups': nearby, 'error_message': "You did not enter a name. Please type your name or nickname." } return render(request, 'discover/organize.html', context) else: new_meetup = get_object_or_404(Meetup, pk=selected_meetup) new_trip = Trip(meetup_pt=new_meetup, organizer=organizer, date=timezone.now() + timedelta(hours=9)) new_trip.save() ip = request.session['host_ip'] new_passenger = Passenger(trip=new_trip, name=organizer, ip=ip, latitude=lat, longitude=long) new_passenger.save() request.session['joined_trip'] = new_trip.id request.session['passenger'] = organizer request.session['passengerID'] = new_passenger.id return HttpResponseRedirect( reverse('discover:detail', args=(new_trip.id, )))
def destination(self, point, bearing, distance=None): point = Point(point) lat1 = units.radians(degrees=point.latitude) lng1 = units.radians(degrees=point.longitude) bearing = units.radians(degrees=bearing) if distance is None: distance = self if isinstance(distance, Distance): distance = distance.kilometers ellipsoid = self.ELLIPSOID if isinstance(ellipsoid, string_compare): ellipsoid = ELLIPSOIDS[ellipsoid] major, minor, f = ellipsoid tan_reduced1 = (1 - f) * tan(lat1) cos_reduced1 = 1 / sqrt(1 + tan_reduced1**2) sin_reduced1 = tan_reduced1 * cos_reduced1 sin_bearing, cos_bearing = sin(bearing), cos(bearing) sigma1 = atan2(tan_reduced1, cos_bearing) sin_alpha = cos_reduced1 * sin_bearing cos_sq_alpha = 1 - sin_alpha**2 u_sq = cos_sq_alpha * (major**2 - minor**2) / minor**2 A = 1 + u_sq / 16384. * (4096 + u_sq * (-768 + u_sq * (320 - 175 * u_sq))) B = u_sq / 1024. * (256 + u_sq * (-128 + u_sq * (74 - 47 * u_sq))) sigma = distance / (minor * A) sigma_prime = 2 * pi while abs(sigma - sigma_prime) > 10e-12: cos2_sigma_m = cos(2 * sigma1 + sigma) sin_sigma, cos_sigma = sin(sigma), cos(sigma) delta_sigma = B * sin_sigma * ( cos2_sigma_m + B / 4. * (cos_sigma * (-1 + 2 * cos2_sigma_m) - B / 6. * cos2_sigma_m * (-3 + 4 * sin_sigma**2) * (-3 + 4 * cos2_sigma_m**2))) sigma_prime = sigma sigma = distance / (minor * A) + delta_sigma sin_sigma, cos_sigma = sin(sigma), cos(sigma) lat2 = atan2( sin_reduced1 * cos_sigma + cos_reduced1 * sin_sigma * cos_bearing, (1 - f) * sqrt(sin_alpha**2 + (sin_reduced1 * sin_sigma - cos_reduced1 * cos_sigma * cos_bearing)**2)) lambda_lng = atan2( sin_sigma * sin_bearing, cos_reduced1 * cos_sigma - sin_reduced1 * sin_sigma * cos_bearing) C = f / 16. * cos_sq_alpha * (4 + f * (4 - 3 * cos_sq_alpha)) delta_lng = (lambda_lng - (1 - C) * f * sin_alpha * (sigma + C * sin_sigma * (cos2_sigma_m + C * cos_sigma * (-1 + 2 * cos2_sigma_m**2)))) final_bearing = atan2( sin_alpha, cos_reduced1 * cos_sigma * cos_bearing - sin_reduced1 * sin_sigma) lng2 = lng1 + delta_lng return Point(units.degrees(radians=lat2), units.degrees(radians=lng2))
def measure(self, a, b): a, b = Point(a), Point(b) lat1, lng1 = radians(degrees=a.latitude), radians(degrees=a.longitude) lat2, lng2 = radians(degrees=b.latitude), radians(degrees=b.longitude) if isinstance(self.ELLIPSOID, string_compare): major, minor, f = ELLIPSOIDS[self.ELLIPSOID] else: major, minor, f = self.ELLIPSOID delta_lng = lng2 - lng1 reduced_lat1 = atan((1 - f) * tan(lat1)) reduced_lat2 = atan((1 - f) * tan(lat2)) sin_reduced1, cos_reduced1 = sin(reduced_lat1), cos(reduced_lat1) sin_reduced2, cos_reduced2 = sin(reduced_lat2), cos(reduced_lat2) lambda_lng = delta_lng lambda_prime = 2 * pi iter_limit = 20 while abs(lambda_lng - lambda_prime) > 10e-12 and iter_limit > 0: sin_lambda_lng, cos_lambda_lng = sin(lambda_lng), cos(lambda_lng) sin_sigma = sqrt( (cos_reduced2 * sin_lambda_lng) ** 2 + (cos_reduced1 * sin_reduced2 - sin_reduced1 * cos_reduced2 * cos_lambda_lng) ** 2 ) if sin_sigma == 0: return 0 # Coincident points cos_sigma = ( sin_reduced1 * sin_reduced2 + cos_reduced1 * cos_reduced2 * cos_lambda_lng ) sigma = atan2(sin_sigma, cos_sigma) sin_alpha = ( cos_reduced1 * cos_reduced2 * sin_lambda_lng / sin_sigma ) cos_sq_alpha = 1 - sin_alpha ** 2 if cos_sq_alpha != 0: cos2_sigma_m = cos_sigma - 2 * ( sin_reduced1 * sin_reduced2 / cos_sq_alpha ) else: cos2_sigma_m = 0.0 # Equatorial line C = f / 16. * cos_sq_alpha * (4 + f * (4 - 3 * cos_sq_alpha)) lambda_prime = lambda_lng lambda_lng = ( delta_lng + (1 - C) * f * sin_alpha * ( sigma + C * sin_sigma * ( cos2_sigma_m + C * cos_sigma * ( -1 + 2 * cos2_sigma_m ** 2 ) ) ) ) iter_limit -= 1 if iter_limit == 0: raise ValueError("Vincenty formula failed to converge!") u_sq = cos_sq_alpha * (major ** 2 - minor ** 2) / minor ** 2 A = 1 + u_sq / 16384. * ( 4096 + u_sq * (-768 + u_sq * (320 - 175 * u_sq)) ) B = u_sq / 1024. * (256 + u_sq * (-128 + u_sq * (74 - 47 * u_sq))) delta_sigma = ( B * sin_sigma * ( cos2_sigma_m + B / 4. * ( cos_sigma * ( -1 + 2 * cos2_sigma_m ** 2 ) - B / 6. * cos2_sigma_m * ( -3 + 4 * sin_sigma ** 2 ) * ( -3 + 4 * cos2_sigma_m ** 2 ) ) ) ) #Compute the Bearing #http://en.wikipedia.org/wiki/Vincenty%27s_formulae #U1 = reduced_lat1 #U2 = reduced_lat2 cl = cos_lambda_lng sl = sin_lambda_lng c1 = cos_reduced1 c2 = cos_reduced2 s1 = sin_reduced1 s2 = sin_reduced2 a1 = atan2(c2* sl, c1*s2 - s1*c2*cl) a2 = atan2(c1* sl, -s1*c2 + c1*s2*cl) self.startbearingdeg = units.degrees(radians=a1) self.endbearingdeg = units.degrees(radians=a2) s = minor * A * (sigma - delta_sigma) return s
def get_bounding_box(latitude, longitude, distancekm): rough_distance = units.degrees(arcminutes=units.nautical( kilometers=distancekm)) * 2 return latitude - rough_distance, latitude + rough_distance, longitude - rough_distance, longitude + rough_distance
def get_offset(distance_range=10): rough_distance = units.degrees(arcminutes=units.nautical(kilometers=distance_range)) * 2 return rough_distance
def distance_to_degrees(d): #Just an approximation, but speeds up clustering by a huge amount and doesnt introduce much error #over small distances return degrees(arcminutes=nautical(meters=d))