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 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))
